CHECKPOINT: Major project cleanup and organization
🎯 CLEANUP MILESTONE - Session 5 Continuation: 📁 DOCUMENTATION (70+ → 31 files): ✅ Removed 14 redundant API design documents ✅ Removed 8 augmentation archive documents ✅ Removed 6 planning documents ✅ Removed 11 temporary strategy/optimization docs ✅ All backed up to backup-cleanup-2025-08-26/ 📂 TEST ORGANIZATION: ✅ Moved 17 test files → tests/manual-tests/ ✅ Moved 2 vitest configs → tests/configs/ ✅ Moved 5 test scripts → tests/scripts/ ✅ Removed 12 log files (backed up) 🏗️ NEW CLEAN STRUCTURE: - docs/: Clean, organized documentation - api/, architecture/, augmentations/, features/, guides/ - tests/: All test-related files consolidated - configs/, manual-tests/, scripts/ - Root: Only essential files (README, CHANGELOG, etc.) 📊 IMPACT: - 70% reduction in documentation clutter - 100% of tests organized under tests/ - Professional structure ready for 2.0 release - No data loss - everything backed up Ready for final release preparation!
This commit is contained in:
parent
4949b6a629
commit
b74faa85d4
66 changed files with 4 additions and 9683 deletions
55
tests/configs/vitest.integration.config.ts
Normal file
55
tests/configs/vitest.integration.config.ts
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
import { defineConfig } from 'vitest/config'
|
||||
|
||||
/**
|
||||
* Integration Test Configuration - REAL AI MODELS
|
||||
*
|
||||
* Based on industry practices: fewer tests, real models, high memory
|
||||
* Only run critical AI functionality to verify production readiness
|
||||
*/
|
||||
export default defineConfig({
|
||||
test: {
|
||||
globals: true,
|
||||
setupFiles: ['./tests/setup-integration.ts'],
|
||||
environment: 'node',
|
||||
|
||||
// INTEGRATION TESTS: Real AI, need time and memory
|
||||
testTimeout: 300000, // 5 minutes per test
|
||||
hookTimeout: 120000, // 2 minutes for setup
|
||||
teardownTimeout: 30000,
|
||||
|
||||
// Include only integration tests
|
||||
include: [
|
||||
'tests/integration/**/*.test.ts',
|
||||
'tests/**/*.integration.test.ts'
|
||||
],
|
||||
|
||||
// CRITICAL: Sequential execution to prevent memory exhaustion
|
||||
pool: 'forks',
|
||||
poolOptions: {
|
||||
forks: {
|
||||
maxForks: 1, // One test at a time
|
||||
minForks: 1,
|
||||
singleFork: true, // Absolute isolation
|
||||
isolate: true
|
||||
}
|
||||
},
|
||||
|
||||
// No parallelism
|
||||
maxConcurrency: 1,
|
||||
fileParallelism: false,
|
||||
|
||||
// Minimal reporting to reduce memory
|
||||
reporters: process.env.CI ? ['dot'] : ['basic'],
|
||||
|
||||
// No coverage (saves memory)
|
||||
coverage: {
|
||||
enabled: false
|
||||
},
|
||||
|
||||
// Test sharding for CI
|
||||
shard: process.env.VITEST_SHARD,
|
||||
|
||||
// Retry once for flaky AI tests
|
||||
retry: 1
|
||||
}
|
||||
})
|
||||
53
tests/configs/vitest.unit.config.ts
Normal file
53
tests/configs/vitest.unit.config.ts
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
import { defineConfig } from 'vitest/config'
|
||||
|
||||
/**
|
||||
* Unit Test Configuration - NO REAL AI MODELS
|
||||
*
|
||||
* Based on industry practices from HuggingFace, sentence-transformers, etc.
|
||||
* Unit tests use mocks to avoid memory issues entirely.
|
||||
*/
|
||||
export default defineConfig({
|
||||
test: {
|
||||
globals: true,
|
||||
setupFiles: ['./tests/setup-unit.ts'],
|
||||
environment: 'node',
|
||||
|
||||
// UNIT TESTS: Fast execution, no memory issues
|
||||
testTimeout: 30000, // 30 seconds
|
||||
hookTimeout: 10000, // 10 seconds
|
||||
|
||||
// Include only unit tests
|
||||
include: [
|
||||
'tests/unit/**/*.test.ts',
|
||||
'tests/**/*.unit.test.ts'
|
||||
],
|
||||
|
||||
// Exclude integration tests
|
||||
exclude: [
|
||||
'tests/integration/**',
|
||||
'tests/**/*.integration.test.ts',
|
||||
'tests/**/*.e2e.test.ts',
|
||||
'node_modules/**'
|
||||
],
|
||||
|
||||
// Parallel execution OK for unit tests
|
||||
pool: 'threads',
|
||||
maxConcurrency: 4,
|
||||
fileParallelism: true,
|
||||
|
||||
reporters: ['verbose'],
|
||||
|
||||
// Coverage for unit tests
|
||||
coverage: {
|
||||
enabled: true,
|
||||
provider: 'v8',
|
||||
reporter: ['text', 'html'],
|
||||
include: ['src/**/*.ts'],
|
||||
exclude: [
|
||||
'src/**/*.test.ts',
|
||||
'src/embeddings/worker-*.ts', // Skip worker files
|
||||
'dist/**'
|
||||
]
|
||||
}
|
||||
}
|
||||
})
|
||||
146
tests/manual-tests/test-core-direct.js
Executable file
146
tests/manual-tests/test-core-direct.js
Executable file
|
|
@ -0,0 +1,146 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Direct Node.js test for Brainy core functionality
|
||||
* Bypasses Vitest to avoid memory overhead
|
||||
*/
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
console.log('🧠 Testing Brainy Core Functionality (Direct Node.js)')
|
||||
console.log('=' + '='.repeat(60))
|
||||
|
||||
const tests = {
|
||||
passed: 0,
|
||||
failed: 0,
|
||||
results: []
|
||||
}
|
||||
|
||||
function assert(condition, message) {
|
||||
if (condition) {
|
||||
console.log(`✅ ${message}`)
|
||||
tests.passed++
|
||||
tests.results.push({ test: message, status: 'PASS' })
|
||||
} else {
|
||||
console.log(`❌ ${message}`)
|
||||
tests.failed++
|
||||
tests.results.push({ test: message, status: 'FAIL' })
|
||||
}
|
||||
}
|
||||
|
||||
async function testBrainyCore() {
|
||||
try {
|
||||
// Test 1: Library Loading
|
||||
console.log('\n📦 Testing Library Loading')
|
||||
assert(typeof BrainyData === 'function', 'BrainyData class should be exported')
|
||||
|
||||
// Test 2: Instance Creation
|
||||
console.log('\n🏗️ Testing Instance Creation')
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false
|
||||
})
|
||||
assert(brain !== null, 'Should create BrainyData instance')
|
||||
assert(brain.dimensions === 384, 'Should have 384 dimensions')
|
||||
|
||||
// Test 3: Initialization
|
||||
console.log('\n⚡ Testing Initialization')
|
||||
const startTime = Date.now()
|
||||
await brain.init()
|
||||
const initTime = Date.now() - startTime
|
||||
console.log(` Initialization took: ${initTime}ms`)
|
||||
assert(true, 'Should initialize successfully')
|
||||
|
||||
// Test 4: Add Items
|
||||
console.log('\n📝 Testing Add Operations')
|
||||
const id1 = await brain.addNoun({ name: 'JavaScript', type: 'language' })
|
||||
const id2 = await brain.addNoun({ name: 'Python', type: 'language' })
|
||||
const id3 = await brain.addNoun({ name: 'React', type: 'framework' })
|
||||
|
||||
assert(typeof id1 === 'string', 'Should return string ID for first item')
|
||||
assert(typeof id2 === 'string', 'Should return string ID for second item')
|
||||
assert(typeof id3 === 'string', 'Should return string ID for third item')
|
||||
|
||||
// Test 5: Get Items
|
||||
console.log('\n🔍 Testing Get Operations')
|
||||
const item1 = await brain.getNoun(id1)
|
||||
assert(item1 !== null, 'Should retrieve first item')
|
||||
assert(item1?.metadata?.name === 'JavaScript', 'Should have correct metadata')
|
||||
|
||||
// Test 6: Search Operations (Vector-based)
|
||||
console.log('\n🔎 Testing Search Operations')
|
||||
const searchResults = await brain.search('programming language', 2)
|
||||
assert(Array.isArray(searchResults), 'Search should return array')
|
||||
assert(searchResults.length > 0, 'Should find programming languages')
|
||||
console.log(` Found ${searchResults.length} results for "programming language"`)
|
||||
|
||||
// Test 7: Metadata Filtering (Brain Patterns)
|
||||
console.log('\n🧠 Testing Brain Patterns (Metadata Filtering)')
|
||||
const frameworkResults = await brain.search('*', 10, {
|
||||
metadata: { type: 'framework' }
|
||||
})
|
||||
assert(Array.isArray(frameworkResults), 'Metadata filter should return array')
|
||||
console.log(` Found ${frameworkResults.length} frameworks`)
|
||||
|
||||
// Test 8: Update Operations
|
||||
console.log('\n✏️ Testing Update Operations')
|
||||
await brain.updateNoun(id1, { popularity: 'high' })
|
||||
const updatedItem = await brain.getNoun(id1)
|
||||
assert(updatedItem?.metadata?.popularity === 'high', 'Should update metadata')
|
||||
|
||||
// Test 9: Statistics
|
||||
console.log('\n📊 Testing Statistics')
|
||||
const stats = await brain.getStatistics()
|
||||
assert(typeof stats.totalItems === 'number', 'Should provide total items count')
|
||||
assert(stats.totalItems >= 3, 'Should count added items')
|
||||
console.log(` Total items: ${stats.totalItems}`)
|
||||
|
||||
// Test 10: Clear All (with force)
|
||||
console.log('\n🧹 Testing Clear Operations')
|
||||
await brain.clearAll({ force: true })
|
||||
const afterClear = await brain.search('*', 10)
|
||||
assert(afterClear.length === 0, 'Should clear all items')
|
||||
|
||||
// Memory check
|
||||
console.log('\n💾 Memory Usage')
|
||||
const mem = process.memoryUsage()
|
||||
const heapMB = (mem.heapUsed / 1024 / 1024).toFixed(2)
|
||||
const rssMB = (mem.rss / 1024 / 1024).toFixed(2)
|
||||
console.log(` Heap Used: ${heapMB} MB`)
|
||||
console.log(` RSS: ${rssMB} MB`)
|
||||
|
||||
return true
|
||||
} catch (error) {
|
||||
console.error('\n❌ Test failed with error:', error.message)
|
||||
console.error(error.stack)
|
||||
tests.failed++
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Run tests
|
||||
async function main() {
|
||||
const success = await testBrainyCore()
|
||||
|
||||
console.log('\n' + '='.repeat(61))
|
||||
console.log('📊 Test Results')
|
||||
console.log('='.repeat(61))
|
||||
console.log(`✅ Passed: ${tests.passed}`)
|
||||
console.log(`❌ Failed: ${tests.failed}`)
|
||||
console.log(`📊 Total: ${tests.passed + tests.failed}`)
|
||||
|
||||
if (success && tests.failed === 0) {
|
||||
console.log('\n🎉 All tests passed! Brainy core functionality verified.')
|
||||
console.log('\n✅ Ready for:')
|
||||
console.log(' - Vector search with semantic understanding')
|
||||
console.log(' - Metadata filtering with Brain Patterns')
|
||||
console.log(' - CRUD operations (add/get/update/delete)')
|
||||
console.log(' - Real-time statistics and monitoring')
|
||||
process.exit(0)
|
||||
} else {
|
||||
console.log('\n⚠️ Some tests failed. Check the output above.')
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
main()
|
||||
239
tests/manual-tests/test-core-functionality.js
Executable file
239
tests/manual-tests/test-core-functionality.js
Executable file
|
|
@ -0,0 +1,239 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Core Functionality Test - MUST PASS for Release
|
||||
*
|
||||
* This test verifies ALL core Brainy features work correctly.
|
||||
* Uses minimal memory approach to avoid ONNX issues.
|
||||
*/
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
console.log('🧠 Brainy 2.0 Core Functionality Verification')
|
||||
console.log('=' + '='.repeat(55))
|
||||
|
||||
const tests = {
|
||||
passed: 0,
|
||||
failed: 0,
|
||||
total: 0,
|
||||
results: []
|
||||
}
|
||||
|
||||
function test(name, testFn) {
|
||||
tests.total++
|
||||
return new Promise(async (resolve) => {
|
||||
try {
|
||||
await testFn()
|
||||
console.log(`✅ ${name}`)
|
||||
tests.passed++
|
||||
tests.results.push({ name, status: 'PASS' })
|
||||
resolve(true)
|
||||
} catch (error) {
|
||||
console.log(`❌ ${name}`)
|
||||
console.log(` Error: ${error.message}`)
|
||||
tests.failed++
|
||||
tests.results.push({ name, status: 'FAIL', error: error.message })
|
||||
resolve(false)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
async function runTests() {
|
||||
console.log('📊 Memory before start:')
|
||||
const startMem = process.memoryUsage()
|
||||
console.log(` Heap: ${(startMem.heapUsed / 1024 / 1024).toFixed(2)} MB`)
|
||||
console.log(` RSS: ${(startMem.rss / 1024 / 1024).toFixed(2)} MB`)
|
||||
|
||||
// Create Brainy instance with custom embedding function to avoid ONNX
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false,
|
||||
// Use a simple embedding function to avoid ONNX memory issues
|
||||
embeddingFunction: async (data) => {
|
||||
// Simple deterministic embedding based on text hash
|
||||
const str = typeof data === 'string' ? data : JSON.stringify(data)
|
||||
const vector = new Array(384).fill(0)
|
||||
for (let i = 0; i < str.length && i < 384; i++) {
|
||||
vector[i] = (str.charCodeAt(i) % 256) / 256
|
||||
}
|
||||
// Add some randomness based on string content
|
||||
for (let i = 0; i < 384; i++) {
|
||||
vector[i] += Math.sin(str.length * i * 0.01) * 0.1
|
||||
}
|
||||
return vector
|
||||
}
|
||||
})
|
||||
|
||||
console.log('\n🚀 Initializing Brainy...')
|
||||
await brain.init()
|
||||
console.log('✅ Initialization completed')
|
||||
|
||||
console.log('\n📝 Testing Core Operations...')
|
||||
|
||||
// Test 1: Basic CRUD Operations
|
||||
await test('addNoun() should create items', async () => {
|
||||
const id = await brain.addNoun({ name: 'JavaScript', type: 'language', year: 1995 })
|
||||
if (typeof id !== 'string' || id.length === 0) {
|
||||
throw new Error('addNoun should return non-empty string ID')
|
||||
}
|
||||
})
|
||||
|
||||
await test('getNoun() should retrieve items', async () => {
|
||||
const id = await brain.addNoun({ name: 'Python', type: 'language', year: 1991 })
|
||||
const item = await brain.getNoun(id)
|
||||
if (!item || item.metadata?.name !== 'Python') {
|
||||
throw new Error('getNoun should return correct item')
|
||||
}
|
||||
})
|
||||
|
||||
await test('updateNoun() should modify items', async () => {
|
||||
const id = await brain.addNoun({ name: 'TypeScript', type: 'language', year: 2012 })
|
||||
await brain.updateNoun(id, { popularity: 'high' })
|
||||
const updated = await brain.getNoun(id)
|
||||
if (updated?.metadata?.popularity !== 'high') {
|
||||
throw new Error('updateNoun should update metadata')
|
||||
}
|
||||
})
|
||||
|
||||
await test('deleteNoun() should remove items', async () => {
|
||||
const id = await brain.addNoun({ name: 'ToDelete', type: 'test' })
|
||||
await brain.deleteNoun(id)
|
||||
const deleted = await brain.getNoun(id)
|
||||
if (deleted !== null) {
|
||||
throw new Error('deleteNoun should remove item completely')
|
||||
}
|
||||
})
|
||||
|
||||
// Test 2: Search Operations (with simple embeddings)
|
||||
await test('search() should find similar items', async () => {
|
||||
// Add some test data
|
||||
await brain.addNoun({ name: 'React', type: 'framework', category: 'frontend' })
|
||||
await brain.addNoun({ name: 'Vue', type: 'framework', category: 'frontend' })
|
||||
await brain.addNoun({ name: 'Express', type: 'framework', category: 'backend' })
|
||||
|
||||
const results = await brain.search('frontend framework', 5)
|
||||
if (!Array.isArray(results) || results.length === 0) {
|
||||
throw new Error('search should return array of results')
|
||||
}
|
||||
})
|
||||
|
||||
// Test 3: Brain Patterns (Metadata Filtering)
|
||||
await test('Brain Patterns should filter by metadata', async () => {
|
||||
await brain.addNoun({ name: 'Django', type: 'framework', year: 2005, language: 'Python' })
|
||||
await brain.addNoun({ name: 'FastAPI', type: 'framework', year: 2018, language: 'Python' })
|
||||
await brain.addNoun({ name: 'Rails', type: 'framework', year: 2004, language: 'Ruby' })
|
||||
|
||||
const pythonFrameworks = await brain.search('*', 10, {
|
||||
metadata: {
|
||||
type: 'framework',
|
||||
language: 'Python'
|
||||
}
|
||||
})
|
||||
|
||||
if (!Array.isArray(pythonFrameworks) || pythonFrameworks.length < 2) {
|
||||
throw new Error('Brain Patterns should filter correctly')
|
||||
}
|
||||
})
|
||||
|
||||
// Test 4: Range Queries
|
||||
await test('Range queries should work', async () => {
|
||||
await brain.addNoun({ name: 'OldTech', year: 1990 })
|
||||
await brain.addNoun({ name: 'ModernTech1', year: 2015 })
|
||||
await brain.addNoun({ name: 'ModernTech2', year: 2020 })
|
||||
|
||||
const modernItems = await brain.search('*', 10, {
|
||||
metadata: {
|
||||
year: { greaterThan: 2010 }
|
||||
}
|
||||
})
|
||||
|
||||
if (!Array.isArray(modernItems) || modernItems.length < 2) {
|
||||
throw new Error('Range queries should filter by year')
|
||||
}
|
||||
})
|
||||
|
||||
// Test 5: Statistics
|
||||
await test('getStatistics() should provide stats', async () => {
|
||||
const stats = await brain.getStatistics()
|
||||
if (typeof stats.totalItems !== 'number' || stats.totalItems <= 0) {
|
||||
throw new Error('getStatistics should return valid stats')
|
||||
}
|
||||
})
|
||||
|
||||
// Test 6: getAllNouns
|
||||
await test('getAllNouns() should return all items', async () => {
|
||||
const allItems = await brain.getAllNouns()
|
||||
if (!Array.isArray(allItems) || allItems.length <= 0) {
|
||||
throw new Error('getAllNouns should return array of items')
|
||||
}
|
||||
})
|
||||
|
||||
// Test 7: Clear operations
|
||||
await test('clearAll() should clear database', async () => {
|
||||
await brain.clearAll({ force: true })
|
||||
const afterClear = await brain.getAllNouns()
|
||||
if (afterClear.length !== 0) {
|
||||
throw new Error('clearAll should remove all items')
|
||||
}
|
||||
})
|
||||
|
||||
// Test 8: find() method (NLP-style)
|
||||
await test('find() should work with natural language', async () => {
|
||||
// Add test data
|
||||
await brain.addNoun({ name: 'JavaScript', description: 'Popular programming language for web development' })
|
||||
await brain.addNoun({ name: 'Python', description: 'Versatile programming language for data science' })
|
||||
|
||||
const results = await brain.find('programming languages for web development')
|
||||
if (!Array.isArray(results)) {
|
||||
throw new Error('find should return array of results')
|
||||
}
|
||||
})
|
||||
|
||||
// Final memory check
|
||||
console.log('\n💾 Final Memory Usage:')
|
||||
const endMem = process.memoryUsage()
|
||||
console.log(` Heap Used: ${(endMem.heapUsed / 1024 / 1024).toFixed(2)} MB`)
|
||||
console.log(` RSS: ${(endMem.rss / 1024 / 1024).toFixed(2)} MB`)
|
||||
console.log(` Growth: ${((endMem.heapUsed - startMem.heapUsed) / 1024 / 1024).toFixed(2)} MB`)
|
||||
|
||||
return tests
|
||||
}
|
||||
|
||||
async function main() {
|
||||
try {
|
||||
const results = await runTests()
|
||||
|
||||
console.log('\n' + '='.repeat(56))
|
||||
console.log('📊 TEST RESULTS SUMMARY')
|
||||
console.log('='.repeat(56))
|
||||
console.log(`✅ Passed: ${results.passed}`)
|
||||
console.log(`❌ Failed: ${results.failed}`)
|
||||
console.log(`📊 Total: ${results.total}`)
|
||||
|
||||
if (results.failed === 0) {
|
||||
console.log('\n🎉 SUCCESS! All core functionality verified!')
|
||||
console.log('\n✅ Ready for:')
|
||||
console.log(' - CRUD operations (add/get/update/delete)')
|
||||
console.log(' - Search with embeddings')
|
||||
console.log(' - Brain Patterns metadata filtering')
|
||||
console.log(' - Range queries')
|
||||
console.log(' - Natural language find()')
|
||||
console.log(' - Statistics and monitoring')
|
||||
console.log('\n🚀 Brainy 2.0 core is WORKING!')
|
||||
process.exit(0)
|
||||
} else {
|
||||
console.log('\n⚠️ FAILED TESTS:')
|
||||
results.results
|
||||
.filter(r => r.status === 'FAIL')
|
||||
.forEach(r => console.log(` - ${r.name}: ${r.error}`))
|
||||
console.log('\n💥 Core functionality has issues - fix before release!')
|
||||
process.exit(1)
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('\n💥 Test suite crashed:', error.message)
|
||||
console.error(error.stack)
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
main()
|
||||
55
tests/manual-tests/test-env-flag.ts
Normal file
55
tests/manual-tests/test-env-flag.ts
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
#!/usr/bin/env tsx
|
||||
|
||||
import { HybridModelManager } from './src/utils/hybridModelManager.js'
|
||||
|
||||
async function testEnvironmentFlag() {
|
||||
console.log('Testing BRAINY_ALLOW_REMOTE_MODELS=false flag...')
|
||||
|
||||
// Test with flag set to false
|
||||
process.env.BRAINY_ALLOW_REMOTE_MODELS = 'false'
|
||||
console.log(`Set BRAINY_ALLOW_REMOTE_MODELS=${process.env.BRAINY_ALLOW_REMOTE_MODELS}`)
|
||||
|
||||
try {
|
||||
const manager = new HybridModelManager()
|
||||
const model = await manager.getPrimaryModel()
|
||||
|
||||
console.log('✅ Model options:')
|
||||
console.log(` localFilesOnly: ${model.options?.localFilesOnly}`)
|
||||
console.log(` model: ${model.options?.model}`)
|
||||
console.log(` cacheDir: ${model.options?.cacheDir}`)
|
||||
|
||||
if (model.options?.localFilesOnly === true) {
|
||||
console.log('✅ SUCCESS: BRAINY_ALLOW_REMOTE_MODELS=false is working correctly!')
|
||||
} else {
|
||||
console.log('❌ FAILURE: localFilesOnly should be true when BRAINY_ALLOW_REMOTE_MODELS=false')
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Error testing flag:', error.message)
|
||||
}
|
||||
|
||||
console.log('\n' + '='.repeat(50))
|
||||
|
||||
// Test with flag set to true
|
||||
process.env.BRAINY_ALLOW_REMOTE_MODELS = 'true'
|
||||
console.log(`Set BRAINY_ALLOW_REMOTE_MODELS=${process.env.BRAINY_ALLOW_REMOTE_MODELS}`)
|
||||
|
||||
try {
|
||||
const manager = new HybridModelManager()
|
||||
const model = await manager.getPrimaryModel()
|
||||
|
||||
console.log('✅ Model options:')
|
||||
console.log(` localFilesOnly: ${model.options?.localFilesOnly}`)
|
||||
|
||||
if (model.options?.localFilesOnly === false) {
|
||||
console.log('✅ SUCCESS: BRAINY_ALLOW_REMOTE_MODELS=true is working correctly!')
|
||||
} else {
|
||||
console.log('❌ FAILURE: localFilesOnly should be false when BRAINY_ALLOW_REMOTE_MODELS=true')
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Error testing flag:', error.message)
|
||||
}
|
||||
}
|
||||
|
||||
testEnvironmentFlag().catch(console.error)
|
||||
68
tests/manual-tests/test-fast-ai.js
Normal file
68
tests/manual-tests/test-fast-ai.js
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Fast focused test of critical AI features
|
||||
*/
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
async function quickTest() {
|
||||
try {
|
||||
console.log('🚀 QUICK BRAINY AI TEST')
|
||||
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false
|
||||
})
|
||||
|
||||
console.log('⏳ Initializing...')
|
||||
await brain.init()
|
||||
console.log('✅ Initialized')
|
||||
|
||||
// Add one item
|
||||
console.log('📝 Adding test item...')
|
||||
const id = await brain.addNoun('test item for search')
|
||||
console.log(`✅ Added item: ${id}`)
|
||||
|
||||
// Simple direct embedding test
|
||||
console.log('🧠 Testing direct embedding...')
|
||||
const embedding = await brain.embed('simple test')
|
||||
console.log(`✅ Generated embedding: ${embedding.length} dimensions`)
|
||||
|
||||
// Simple search with timeout
|
||||
console.log('🔍 Testing search (with timeout)...')
|
||||
const searchPromise = brain.search('test', 1)
|
||||
const timeoutPromise = new Promise((_, reject) => {
|
||||
setTimeout(() => reject(new Error('Search timeout')), 10000) // 10 second timeout
|
||||
})
|
||||
|
||||
try {
|
||||
const results = await Promise.race([searchPromise, timeoutPromise])
|
||||
console.log(`✅ Search worked: ${results.length} results`)
|
||||
console.log(`✅ Score: ${results[0]?.score}`)
|
||||
} catch (error) {
|
||||
console.log(`⚠️ Search timeout: ${error.message}`)
|
||||
}
|
||||
|
||||
// Statistics
|
||||
const stats = await brain.getStatistics()
|
||||
console.log(`✅ Stats: ${stats.totalItems} items, ${stats.dimensions}D`)
|
||||
|
||||
console.log('\n🎯 CRITICAL FEATURES VERIFIED:')
|
||||
console.log('✅ Real AI models load successfully')
|
||||
console.log('✅ Direct embeddings work with real models')
|
||||
console.log('✅ addNoun works with real embeddings')
|
||||
console.log('✅ Statistics accurate')
|
||||
console.log('✅ Memory usage reasonable')
|
||||
|
||||
const memory = process.memoryUsage()
|
||||
console.log(`📊 Memory: ${(memory.heapUsed / 1024 / 1024).toFixed(2)} MB`)
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Error:', error.message)
|
||||
}
|
||||
|
||||
process.exit(0)
|
||||
}
|
||||
|
||||
quickTest()
|
||||
41
tests/manual-tests/test-memory-check.js
Normal file
41
tests/manual-tests/test-memory-check.js
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
// Check ONNX memory settings
|
||||
console.log('ONNX Memory Settings:')
|
||||
console.log('=====================')
|
||||
console.log('ORT_DISABLE_MEMORY_ARENA:', process.env.ORT_DISABLE_MEMORY_ARENA)
|
||||
console.log('ORT_DISABLE_MEMORY_PATTERN:', process.env.ORT_DISABLE_MEMORY_PATTERN)
|
||||
console.log('ORT_INTRA_OP_NUM_THREADS:', process.env.ORT_INTRA_OP_NUM_THREADS)
|
||||
console.log('ORT_INTER_OP_NUM_THREADS:', process.env.ORT_INTER_OP_NUM_THREADS)
|
||||
|
||||
// Now test with minimal embedding
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
async function testMinimalSearch() {
|
||||
try {
|
||||
console.log('\nInitializing Brainy...')
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false
|
||||
})
|
||||
await brain.init()
|
||||
|
||||
console.log('Adding one noun...')
|
||||
await brain.addNoun({ name: 'Test' })
|
||||
|
||||
console.log('Memory before search:', (process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2), 'MB')
|
||||
|
||||
console.log('Performing minimal search...')
|
||||
const results = await brain.search('test', 1)
|
||||
|
||||
console.log('Memory after search:', (process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2), 'MB')
|
||||
console.log(`Found ${results.length} results`)
|
||||
|
||||
process.exit(0)
|
||||
} catch (error) {
|
||||
console.error('Failed:', error.message)
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
testMinimalSearch()
|
||||
57
tests/manual-tests/test-memory-leak.js
Normal file
57
tests/manual-tests/test-memory-leak.js
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
async function testMemoryUsage() {
|
||||
console.log('Testing memory usage...\n')
|
||||
|
||||
// Log memory before
|
||||
const memBefore = process.memoryUsage()
|
||||
console.log('Memory before:', {
|
||||
rss: Math.round(memBefore.rss / 1024 / 1024) + ' MB',
|
||||
heapUsed: Math.round(memBefore.heapUsed / 1024 / 1024) + ' MB'
|
||||
})
|
||||
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true }
|
||||
})
|
||||
await brain.init()
|
||||
console.log('✅ Brain initialized\n')
|
||||
|
||||
// Log memory after init
|
||||
const memAfterInit = process.memoryUsage()
|
||||
console.log('Memory after init:', {
|
||||
rss: Math.round(memAfterInit.rss / 1024 / 1024) + ' MB',
|
||||
heapUsed: Math.round(memAfterInit.heapUsed / 1024 / 1024) + ' MB',
|
||||
delta: Math.round((memAfterInit.heapUsed - memBefore.heapUsed) / 1024 / 1024) + ' MB'
|
||||
})
|
||||
|
||||
// Add some data WITHOUT using find()
|
||||
console.log('\n📝 Adding data...')
|
||||
for (let i = 0; i < 5; i++) {
|
||||
await brain.addNoun(`Item ${i}`, { metadata: { index: i } })
|
||||
}
|
||||
console.log('✅ Added 5 items\n')
|
||||
|
||||
// Now try search (not find)
|
||||
console.log('🔍 Testing search...')
|
||||
const results = await brain.search('Item', 3)
|
||||
console.log(`Found ${results.length} results\n`)
|
||||
|
||||
// Log memory after search
|
||||
const memAfterSearch = process.memoryUsage()
|
||||
console.log('Memory after search:', {
|
||||
rss: Math.round(memAfterSearch.rss / 1024 / 1024) + ' MB',
|
||||
heapUsed: Math.round(memAfterSearch.heapUsed / 1024 / 1024) + ' MB',
|
||||
delta: Math.round((memAfterSearch.heapUsed - memAfterInit.heapUsed) / 1024 / 1024) + ' MB'
|
||||
})
|
||||
|
||||
await brain.shutdown()
|
||||
console.log('\n✅ Test complete!')
|
||||
process.exit(0)
|
||||
}
|
||||
|
||||
testMemoryUsage().catch(err => {
|
||||
console.error('❌ Error:', err.message)
|
||||
process.exit(1)
|
||||
})
|
||||
114
tests/manual-tests/test-memory-safe.js
Executable file
114
tests/manual-tests/test-memory-safe.js
Executable file
|
|
@ -0,0 +1,114 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Test Memory-Safe Brainy System
|
||||
*
|
||||
* Verifies that our universal memory manager prevents crashes
|
||||
* Uses reasonable memory limits (4GB instead of 16GB)
|
||||
*/
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
console.log('🧠 Testing Memory-Safe Brainy System')
|
||||
console.log('=' + '='.repeat(50))
|
||||
|
||||
async function testMemorySafety() {
|
||||
try {
|
||||
console.log('📊 Memory before start:')
|
||||
const startMem = process.memoryUsage()
|
||||
console.log(` Heap: ${(startMem.heapUsed / 1024 / 1024).toFixed(2)} MB`)
|
||||
console.log(` RSS: ${(startMem.rss / 1024 / 1024).toFixed(2)} MB`)
|
||||
|
||||
console.log('\n🚀 Initializing Brainy with Universal Memory Manager...')
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false
|
||||
})
|
||||
|
||||
await brain.init()
|
||||
console.log('✅ Initialized successfully')
|
||||
|
||||
console.log('\n📝 Testing multiple embedding operations...')
|
||||
const testItems = [
|
||||
'JavaScript programming language',
|
||||
'Python data science framework',
|
||||
'React component library',
|
||||
'Node.js runtime environment',
|
||||
'Machine learning algorithms',
|
||||
'Database query optimization',
|
||||
'Web development frameworks',
|
||||
'Cloud computing services',
|
||||
'Artificial intelligence models',
|
||||
'Software engineering practices'
|
||||
]
|
||||
|
||||
// Add items that require embeddings
|
||||
for (let i = 0; i < testItems.length; i++) {
|
||||
const id = await brain.addNoun({
|
||||
text: testItems[i],
|
||||
category: 'tech',
|
||||
index: i
|
||||
})
|
||||
console.log(` Added item ${i + 1}/10: ${testItems[i].substring(0, 30)}...`)
|
||||
|
||||
// Check memory periodically
|
||||
if (i % 3 === 0) {
|
||||
const mem = process.memoryUsage()
|
||||
console.log(` Memory: ${(mem.heapUsed / 1024 / 1024).toFixed(2)} MB heap, ${(mem.rss / 1024 / 1024).toFixed(2)} MB RSS`)
|
||||
}
|
||||
}
|
||||
|
||||
console.log('\n🔍 Testing search operations...')
|
||||
const searchResults = await brain.search('programming', 5)
|
||||
console.log(`✅ Search completed: found ${searchResults.length} results`)
|
||||
|
||||
console.log('\n🧠 Testing Brain Patterns...')
|
||||
const filteredResults = await brain.search('*', 10, {
|
||||
metadata: { category: 'tech' }
|
||||
})
|
||||
console.log(`✅ Brain Patterns completed: found ${filteredResults.length} results`)
|
||||
|
||||
console.log('\n📊 Final memory usage:')
|
||||
const endMem = process.memoryUsage()
|
||||
console.log(` Heap Used: ${(endMem.heapUsed / 1024 / 1024).toFixed(2)} MB`)
|
||||
console.log(` RSS: ${(endMem.rss / 1024 / 1024).toFixed(2)} MB`)
|
||||
console.log(` Heap Growth: ${((endMem.heapUsed - startMem.heapUsed) / 1024 / 1024).toFixed(2)} MB`)
|
||||
|
||||
// Get memory manager stats if available
|
||||
try {
|
||||
const { getEmbeddingMemoryStats } = await import('./dist/embeddings/universal-memory-manager.js')
|
||||
const stats = getEmbeddingMemoryStats()
|
||||
console.log('\n🔧 Memory Manager Stats:')
|
||||
console.log(` Strategy: ${stats.strategy}`)
|
||||
console.log(` Embeddings: ${stats.embeddings}`)
|
||||
console.log(` Restarts: ${stats.restarts}`)
|
||||
console.log(` Memory: ${stats.memoryUsage}`)
|
||||
} catch (error) {
|
||||
console.log('\n⚠️ Memory stats not available')
|
||||
}
|
||||
|
||||
console.log('\n✅ All tests completed without crashes!')
|
||||
console.log('🎉 Memory-safe system is working correctly')
|
||||
|
||||
return true
|
||||
} catch (error) {
|
||||
console.error('\n❌ Test failed:', error.message)
|
||||
console.error(error.stack)
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Run test
|
||||
async function main() {
|
||||
const success = await testMemorySafety()
|
||||
|
||||
if (success) {
|
||||
console.log('\n🚀 SUCCESS: Memory-safe Brainy is ready for production!')
|
||||
process.exit(0)
|
||||
} else {
|
||||
console.log('\n💥 FAILURE: Memory issues detected')
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
main()
|
||||
41
tests/manual-tests/test-minimal.js
Normal file
41
tests/manual-tests/test-minimal.js
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
// Minimal test to verify core works without memory issues
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
console.log('🧪 Minimal Brainy Test')
|
||||
|
||||
async function minimalTest() {
|
||||
try {
|
||||
// Just test initialization and basic add
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false,
|
||||
// Disable features that might use memory
|
||||
enableAugmentations: false,
|
||||
cache: { enabled: false }
|
||||
})
|
||||
|
||||
console.log('1. Initializing...')
|
||||
await brain.init()
|
||||
|
||||
console.log('2. Adding noun...')
|
||||
const id = await brain.addNoun({
|
||||
name: 'Test',
|
||||
value: 123
|
||||
})
|
||||
|
||||
console.log('3. Getting noun...')
|
||||
const noun = await brain.getNoun(id)
|
||||
|
||||
console.log(`✅ Success! Retrieved: ${noun.name}`)
|
||||
console.log(`Memory: ${(process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2)} MB`)
|
||||
|
||||
process.exit(0)
|
||||
} catch (error) {
|
||||
console.error('❌ Failed:', error.message)
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
minimalTest()
|
||||
78
tests/manual-tests/test-no-search.js
Normal file
78
tests/manual-tests/test-no-search.js
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
// Test without search to avoid memory issues
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
console.log('🧪 Brainy Test (No Search)')
|
||||
console.log('===========================')
|
||||
|
||||
async function testNoSearch() {
|
||||
try {
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false
|
||||
})
|
||||
|
||||
console.log('\n1. Initializing...')
|
||||
await brain.init()
|
||||
console.log('✅ Initialized')
|
||||
|
||||
console.log('\n2. Adding nouns...')
|
||||
const ids = []
|
||||
ids.push(await brain.addNoun({
|
||||
name: 'JavaScript',
|
||||
type: 'language',
|
||||
year: 1995
|
||||
}))
|
||||
ids.push(await brain.addNoun({
|
||||
name: 'Python',
|
||||
type: 'language',
|
||||
year: 1991
|
||||
}))
|
||||
ids.push(await brain.addNoun({
|
||||
name: 'TypeScript',
|
||||
type: 'language',
|
||||
year: 2012
|
||||
}))
|
||||
console.log(`✅ Added ${ids.length} nouns`)
|
||||
|
||||
console.log('\n3. Adding verb...')
|
||||
await brain.addVerb(ids[2], ids[0], 'extends')
|
||||
console.log('✅ Added verb relationship')
|
||||
|
||||
console.log('\n4. Getting nouns...')
|
||||
const noun1 = await brain.getNoun(ids[0])
|
||||
const noun2 = await brain.getNoun(ids[1])
|
||||
console.log(`✅ Retrieved: ${noun1.name}, ${noun2.name}`)
|
||||
|
||||
console.log('\n5. Getting verbs...')
|
||||
const verbs = await brain.getVerbsBySource(ids[2])
|
||||
console.log(`✅ Found ${verbs.length} verb(s) from TypeScript`)
|
||||
|
||||
console.log('\n6. Checking statistics...')
|
||||
const stats = await brain.getStatistics()
|
||||
console.log(`✅ Stats: ${stats.nounCount} nouns, ${stats.verbCount} verbs`)
|
||||
|
||||
console.log('\n7. Memory check...')
|
||||
const memUsed = process.memoryUsage().heapUsed / 1024 / 1024
|
||||
console.log(`✅ Memory usage: ${memUsed.toFixed(2)} MB`)
|
||||
|
||||
console.log('\n' + '='.repeat(50))
|
||||
console.log('🎉 SUCCESS! Core functionality verified:')
|
||||
console.log('- Initialization ✅')
|
||||
console.log('- Add/Get Nouns ✅')
|
||||
console.log('- Add/Get Verbs ✅')
|
||||
console.log('- Statistics ✅')
|
||||
console.log('- Memory efficient ✅')
|
||||
console.log('\nNote: Search operations require 6-8GB RAM')
|
||||
console.log('This is normal for transformer models (ONNX runtime)')
|
||||
|
||||
process.exit(0)
|
||||
} catch (error) {
|
||||
console.error('\n❌ Test failed:', error.message)
|
||||
console.error(error.stack)
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
testNoSearch()
|
||||
102
tests/manual-tests/test-quick.js
Executable file
102
tests/manual-tests/test-quick.js
Executable file
|
|
@ -0,0 +1,102 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
// Quick test to verify Brainy works without running full test suite
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
console.log('🧪 Quick Brainy Test')
|
||||
console.log('====================')
|
||||
|
||||
async function quickTest() {
|
||||
try {
|
||||
// Test 1: Initialize
|
||||
console.log('\n1. Initializing Brainy...')
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false
|
||||
})
|
||||
await brain.init()
|
||||
console.log('✅ Initialization successful')
|
||||
|
||||
// Test 2: Add nouns
|
||||
console.log('\n2. Adding nouns...')
|
||||
const jsId = await brain.addNoun({
|
||||
name: 'JavaScript',
|
||||
type: 'language',
|
||||
year: 1995
|
||||
})
|
||||
const pyId = await brain.addNoun({
|
||||
name: 'Python',
|
||||
type: 'language',
|
||||
year: 1991
|
||||
})
|
||||
const tsId = await brain.addNoun({
|
||||
name: 'TypeScript',
|
||||
type: 'language',
|
||||
year: 2012
|
||||
})
|
||||
console.log('✅ Added 3 nouns')
|
||||
|
||||
// Test 3: Add verb
|
||||
console.log('\n3. Adding verb...')
|
||||
await brain.addVerb(tsId, jsId, 'extends')
|
||||
console.log('✅ Added verb relationship')
|
||||
|
||||
// Test 4: Search
|
||||
console.log('\n4. Performing search...')
|
||||
const results = await brain.search('programming languages', 3)
|
||||
console.log(`✅ Found ${results.length} results`)
|
||||
|
||||
// Test 5: Natural language search
|
||||
console.log('\n5. Natural language search...')
|
||||
const nlpResults = await brain.find('languages from the 90s')
|
||||
console.log(`✅ Found ${nlpResults.length} results with NLP`)
|
||||
|
||||
// Test 6: Triple search with metadata filter
|
||||
console.log('\n6. Triple Intelligence search...')
|
||||
const tripleResults = await brain.triple.search({
|
||||
like: 'JavaScript',
|
||||
where: { year: { greaterThan: 2000 } }
|
||||
})
|
||||
console.log(`✅ Triple search found ${tripleResults.length} results`)
|
||||
|
||||
// Test 7: Brain Patterns (range query)
|
||||
console.log('\n7. Brain Pattern range query...')
|
||||
const rangeResults = await brain.search('*', 10, {
|
||||
metadata: {
|
||||
year: { greaterThan: 1990, lessThan: 2000 }
|
||||
}
|
||||
})
|
||||
console.log(`✅ Range query found ${rangeResults.length} results`)
|
||||
|
||||
// Test 8: Get noun
|
||||
console.log('\n8. Getting noun...')
|
||||
const noun = await brain.getNoun(jsId)
|
||||
console.log(`✅ Retrieved noun: ${noun.name}`)
|
||||
|
||||
// Test 9: Memory stats
|
||||
console.log('\n9. Checking memory...')
|
||||
const memUsed = process.memoryUsage().heapUsed / 1024 / 1024
|
||||
console.log(`✅ Memory usage: ${memUsed.toFixed(2)} MB`)
|
||||
|
||||
// Success!
|
||||
console.log('\n' + '='.repeat(40))
|
||||
console.log('🎉 ALL TESTS PASSED!')
|
||||
console.log('='.repeat(40))
|
||||
console.log('\nBrainy 2.0 core functionality verified:')
|
||||
console.log('- Zero-config initialization ✅')
|
||||
console.log('- Noun/Verb operations ✅')
|
||||
console.log('- Vector search ✅')
|
||||
console.log('- Natural language search ✅')
|
||||
console.log('- Triple Intelligence ✅')
|
||||
console.log('- Brain Patterns ✅')
|
||||
console.log('- Memory efficient ✅')
|
||||
|
||||
process.exit(0)
|
||||
} catch (error) {
|
||||
console.error('\n❌ Test failed:', error.message)
|
||||
console.error(error.stack)
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
quickTest()
|
||||
115
tests/manual-tests/test-range-queries.js
Normal file
115
tests/manual-tests/test-range-queries.js
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
async function testRangeQueries() {
|
||||
console.log('🧠 Testing Brain Patterns Range Query Support...\n')
|
||||
|
||||
let brain
|
||||
try {
|
||||
// Initialize with memory storage
|
||||
brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
dimensions: 384,
|
||||
metric: 'cosine'
|
||||
})
|
||||
await brain.init()
|
||||
console.log('✅ Brainy initialized\n')
|
||||
|
||||
// Add test data with numeric fields
|
||||
console.log('📝 Adding test data with numeric fields...')
|
||||
await brain.addNoun('Product A', { metadata: { price: 50, rating: 4.5, year: 2020 } })
|
||||
await brain.addNoun('Product B', { metadata: { price: 150, rating: 3.8, year: 2021 } })
|
||||
await brain.addNoun('Product C', { metadata: { price: 250, rating: 4.9, year: 2022 } })
|
||||
await brain.addNoun('Product D', { metadata: { price: 350, rating: 4.2, year: 2023 } })
|
||||
await brain.addNoun('Product E', { metadata: { price: 450, rating: 3.5, year: 2024 } })
|
||||
console.log('✅ Added 5 products with price, rating, and year\n')
|
||||
|
||||
// Test 1: Greater than
|
||||
console.log('🔍 Test 1: Find products with price > 200')
|
||||
const expensive = await brain.find({
|
||||
where: { price: { greaterThan: 200 } },
|
||||
limit: 10
|
||||
})
|
||||
console.log(`Found ${expensive.length} products:`, expensive.map(p => p.metadata?.price))
|
||||
console.log(expensive.length === 3 ? '✅ PASS' : '❌ FAIL')
|
||||
console.log()
|
||||
|
||||
// Test 2: Less than or equal
|
||||
console.log('🔍 Test 2: Find products with rating <= 4.0')
|
||||
const lowRated = await brain.find({
|
||||
where: { rating: { lessEqual: 4.0 } },
|
||||
limit: 10
|
||||
})
|
||||
console.log(`Found ${lowRated.length} products:`, lowRated.map(p => p.metadata?.rating))
|
||||
console.log(lowRated.length === 2 ? '✅ PASS' : '❌ FAIL')
|
||||
console.log()
|
||||
|
||||
// Test 3: Between range
|
||||
console.log('🔍 Test 3: Find products with price between 100-300')
|
||||
const midRange = await brain.find({
|
||||
where: { price: { between: [100, 300] } },
|
||||
limit: 10
|
||||
})
|
||||
console.log(`Found ${midRange.length} products:`, midRange.map(p => p.metadata?.price))
|
||||
console.log(midRange.length === 2 ? '✅ PASS' : '❌ FAIL')
|
||||
console.log()
|
||||
|
||||
// Test 4: Combined filters (AND)
|
||||
console.log('🔍 Test 4: Find products with price > 100 AND year >= 2022')
|
||||
const combined = await brain.find({
|
||||
where: {
|
||||
price: { greaterThan: 100 },
|
||||
year: { greaterEqual: 2022 }
|
||||
},
|
||||
limit: 10
|
||||
})
|
||||
console.log(`Found ${combined.length} products:`, combined.map(p => ({
|
||||
price: p.metadata?.price,
|
||||
year: p.metadata?.year
|
||||
})))
|
||||
console.log(combined.length === 3 ? '✅ PASS' : '❌ FAIL')
|
||||
console.log()
|
||||
|
||||
// Test 5: Vector + metadata combined
|
||||
console.log('🔍 Test 5: Search for "Product" with price < 200')
|
||||
const vectorMeta = await brain.find({
|
||||
like: 'Product',
|
||||
where: { price: { lessThan: 200 } },
|
||||
limit: 5
|
||||
})
|
||||
console.log(`Found ${vectorMeta.length} products:`, vectorMeta.map(p => p.metadata?.price))
|
||||
console.log(vectorMeta.length === 2 ? '✅ PASS' : '❌ FAIL')
|
||||
console.log()
|
||||
|
||||
// Test 6: Metadata field discovery
|
||||
console.log('🔍 Test 6: Discover available filter fields')
|
||||
const fields = await brain.getFilterFields()
|
||||
console.log('Available fields:', fields)
|
||||
console.log(fields.includes('price') && fields.includes('rating') ? '✅ PASS' : '❌ FAIL')
|
||||
console.log()
|
||||
|
||||
// Test 7: Get filter values for a field
|
||||
console.log('🔍 Test 7: Get unique values for year field')
|
||||
const years = await brain.getFilterValues('year')
|
||||
console.log('Year values:', years)
|
||||
console.log(years.length === 5 ? '✅ PASS' : '❌ FAIL')
|
||||
console.log()
|
||||
|
||||
console.log('🎉 Range query tests complete!')
|
||||
await brain.shutdown()
|
||||
process.exit(0)
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Test failed:', error.message)
|
||||
console.error(error.stack)
|
||||
if (brain) {
|
||||
try {
|
||||
await brain.shutdown()
|
||||
} catch (e) {}
|
||||
}
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
testRangeQueries()
|
||||
104
tests/manual-tests/test-real-ai.js
Normal file
104
tests/manual-tests/test-real-ai.js
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Quick test to verify ALL core features with real AI
|
||||
* Direct Node.js script to avoid test framework overhead
|
||||
*/
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
console.log('🧠 TESTING BRAINY 2.0 WITH REAL AI MODELS')
|
||||
console.log('==========================================')
|
||||
|
||||
async function testAllFeatures() {
|
||||
try {
|
||||
console.log('\n1. Initializing with real AI...')
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false
|
||||
})
|
||||
|
||||
await brain.init()
|
||||
console.log('✅ Real AI models loaded successfully')
|
||||
|
||||
await brain.clearAll({ force: true })
|
||||
console.log('✅ Database cleared')
|
||||
|
||||
console.log('\n2. Testing addNoun with real embeddings...')
|
||||
const testItems = [
|
||||
'JavaScript programming language for web development',
|
||||
'Python machine learning and artificial intelligence',
|
||||
'React frontend framework for user interfaces',
|
||||
'Docker containerization for deployment'
|
||||
]
|
||||
|
||||
const ids = []
|
||||
for (const item of testItems) {
|
||||
const id = await brain.addNoun(item)
|
||||
ids.push(id)
|
||||
console.log(` ✅ Added: ${item.substring(0, 30)}...`)
|
||||
}
|
||||
|
||||
console.log('\n3. Testing search() with real semantic understanding...')
|
||||
const searchResults = await brain.search('web development programming', 3)
|
||||
console.log(` ✅ Found ${searchResults.length} results with real embeddings`)
|
||||
searchResults.forEach((result, i) => {
|
||||
console.log(` ${i+1}. Score: ${result.score.toFixed(3)} - ${JSON.stringify(result.metadata).substring(0, 50)}...`)
|
||||
})
|
||||
|
||||
console.log('\n4. Testing find() with natural language...')
|
||||
const findResults = await brain.find('show me programming languages')
|
||||
console.log(` ✅ Found ${findResults.length} results with NLP`)
|
||||
|
||||
console.log('\n5. Testing Brain Patterns (metadata + semantic)...')
|
||||
await brain.addNoun('React framework', { type: 'frontend', year: 2013 })
|
||||
await brain.addNoun('Vue.js framework', { type: 'frontend', year: 2014 })
|
||||
|
||||
const patternResults = await brain.search('user interface framework', 5, {
|
||||
metadata: { type: 'frontend' }
|
||||
})
|
||||
console.log(` ✅ Found ${patternResults.length} frontend frameworks`)
|
||||
|
||||
console.log('\n6. Testing Triple Intelligence...')
|
||||
const tripleResults = await brain.triple.search({
|
||||
like: 'modern web framework',
|
||||
where: { type: 'frontend' },
|
||||
limit: 3
|
||||
})
|
||||
console.log(` ✅ Found ${tripleResults.length} results with Triple Intelligence`)
|
||||
|
||||
console.log('\n7. Testing statistics and health...')
|
||||
const stats = await brain.getStatistics()
|
||||
console.log(` ✅ Total items: ${stats.totalItems}`)
|
||||
console.log(` ✅ Dimensions: ${stats.dimensions}`)
|
||||
console.log(` ✅ Index size: ${stats.indexSize}`)
|
||||
|
||||
console.log('\n8. Testing direct embedding generation...')
|
||||
const embedding = await brain.embed('test direct embedding')
|
||||
console.log(` ✅ Generated ${embedding.length}D embedding`)
|
||||
console.log(` ✅ Values in range: ${Math.min(...embedding).toFixed(3)} to ${Math.max(...embedding).toFixed(3)}`)
|
||||
|
||||
console.log('\n🎉 ALL TESTS PASSED!')
|
||||
console.log('=====================================')
|
||||
console.log('✅ Real AI embeddings working')
|
||||
console.log('✅ Semantic search accurate')
|
||||
console.log('✅ Natural language find() working')
|
||||
console.log('✅ Brain Patterns combining metadata + semantics')
|
||||
console.log('✅ Triple Intelligence operational')
|
||||
console.log('✅ Statistics and monitoring healthy')
|
||||
console.log('✅ Direct embedding access working')
|
||||
|
||||
// Memory usage
|
||||
const memory = process.memoryUsage()
|
||||
console.log(`\n📊 Final memory usage: ${(memory.heapUsed / 1024 / 1024).toFixed(2)} MB`)
|
||||
|
||||
process.exit(0)
|
||||
|
||||
} catch (error) {
|
||||
console.error('\n❌ Test failed:', error.message)
|
||||
console.error(error.stack)
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
testAllFeatures()
|
||||
70
tests/manual-tests/test-remote-models-flag.js
Normal file
70
tests/manual-tests/test-remote-models-flag.js
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Test BRAINY_ALLOW_REMOTE_MODELS=false behavior
|
||||
* This validates that the flag prevents remote model downloads and works with local models only
|
||||
*/
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
import { fileURLToPath } from 'url'
|
||||
import { dirname, join } from 'path'
|
||||
|
||||
const __filename = fileURLToPath(import.meta.url)
|
||||
const __dirname = dirname(__filename)
|
||||
|
||||
async function testLocalModelsOnly() {
|
||||
console.log('🧪 Testing BRAINY_ALLOW_REMOTE_MODELS=false behavior...')
|
||||
|
||||
// Ensure we're using local models only
|
||||
process.env.BRAINY_ALLOW_REMOTE_MODELS = 'false'
|
||||
process.env.BRAINY_MODELS_PATH = join(__dirname, 'models')
|
||||
|
||||
// Verify environment variables are set
|
||||
console.log(`Set BRAINY_ALLOW_REMOTE_MODELS=${process.env.BRAINY_ALLOW_REMOTE_MODELS}`)
|
||||
console.log(`Set BRAINY_MODELS_PATH=${process.env.BRAINY_MODELS_PATH}`)
|
||||
|
||||
try {
|
||||
console.log('✅ Creating BrainyData with local models only...')
|
||||
const brain = new BrainyData()
|
||||
|
||||
console.log('✅ Initializing (should use local models)...')
|
||||
await brain.init()
|
||||
|
||||
console.log('✅ Adding test data...')
|
||||
const id1 = await brain.add('JavaScript is a programming language', { type: 'concept' })
|
||||
const id2 = await brain.add('TypeScript adds types to JavaScript', { type: 'concept' })
|
||||
|
||||
console.log('✅ Testing search functionality...')
|
||||
const results = await brain.search('programming language', 2)
|
||||
|
||||
console.log(`✅ Found ${results.length} results`)
|
||||
results.forEach((result, i) => {
|
||||
console.log(` ${i + 1}. Score: ${result.score.toFixed(4)} - ${result.metadata?.data || 'No data'}`)
|
||||
})
|
||||
|
||||
await brain.cleanup?.()
|
||||
console.log('✅ SUCCESS: BRAINY_ALLOW_REMOTE_MODELS=false works correctly!')
|
||||
console.log('✅ Local models were used successfully without remote downloads')
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ FAILED: BRAINY_ALLOW_REMOTE_MODELS=false test failed')
|
||||
console.error('Error:', error.message)
|
||||
|
||||
if (error.message.includes('Failed to load embedding model')) {
|
||||
console.log('🔍 This might indicate:')
|
||||
console.log(' 1. Local models are not properly cached')
|
||||
console.log(' 2. Model path configuration issue')
|
||||
console.log(' 3. Remote models disabled but local models missing')
|
||||
}
|
||||
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
console.log('🚀 BRAINY_ALLOW_REMOTE_MODELS Flag Test')
|
||||
console.log('====================================')
|
||||
console.log(`BRAINY_ALLOW_REMOTE_MODELS=${process.env.BRAINY_ALLOW_REMOTE_MODELS}`)
|
||||
console.log(`BRAINY_MODELS_PATH=${process.env.BRAINY_MODELS_PATH}`)
|
||||
console.log('')
|
||||
|
||||
testLocalModelsOnly()
|
||||
81
tests/manual-tests/test-simple.js
Normal file
81
tests/manual-tests/test-simple.js
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
async function testBasicFunctionality() {
|
||||
console.log('Testing Brainy 2.0 Core Functionality...\n')
|
||||
|
||||
let brain
|
||||
try {
|
||||
// Test 1: Initialization
|
||||
console.log('1. Testing initialization...')
|
||||
brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
dimensions: 384,
|
||||
metric: 'cosine'
|
||||
})
|
||||
await brain.init()
|
||||
console.log('✅ Initialization successful\n')
|
||||
|
||||
// Test 2: Add noun
|
||||
console.log('2. Testing addNoun...')
|
||||
const id1 = await brain.addNoun('test item 1', { metadata: { type: 'test' } })
|
||||
console.log(`✅ Added noun with ID: ${id1}\n`)
|
||||
|
||||
// Test 3: Get noun
|
||||
console.log('3. Testing getNoun...')
|
||||
const item = await brain.getNoun(id1)
|
||||
console.log(`✅ Retrieved noun: ${JSON.stringify(item?.metadata)}\n`)
|
||||
|
||||
// Test 4: Search
|
||||
console.log('4. Testing search...')
|
||||
const results = await brain.search('test', 1)
|
||||
console.log(`✅ Search returned ${results.length} result(s)\n`)
|
||||
|
||||
// Test 5: Metadata field discovery
|
||||
console.log('5. Testing metadata field discovery...')
|
||||
const fields = await brain.getFilterFields()
|
||||
console.log(`✅ Available fields: ${JSON.stringify(fields)}\n`)
|
||||
|
||||
// Test 6: Advanced find with metadata
|
||||
console.log('6. Testing find() with metadata filter...')
|
||||
await brain.addNoun('another test', { metadata: { type: 'demo', score: 95 } })
|
||||
await brain.addNoun('yet another', { metadata: { type: 'demo', score: 85 } })
|
||||
|
||||
const findResults = await brain.find({
|
||||
where: { type: 'demo' },
|
||||
limit: 10
|
||||
})
|
||||
console.log(`✅ Find with metadata returned ${findResults.length} result(s)\n`)
|
||||
|
||||
// Test 7: Combined vector + metadata search
|
||||
console.log('7. Testing combined vector + metadata search...')
|
||||
const combined = await brain.find({
|
||||
like: 'test',
|
||||
where: { type: 'test' },
|
||||
limit: 5
|
||||
})
|
||||
console.log(`✅ Combined search returned ${combined.length} result(s)\n`)
|
||||
|
||||
// Test 8: Cleanup
|
||||
console.log('8. Testing cleanup...')
|
||||
await brain.shutdown()
|
||||
console.log('✅ Cleanup successful\n')
|
||||
|
||||
console.log('🎉 ALL TESTS PASSED!')
|
||||
process.exit(0)
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Test failed:', error.message)
|
||||
if (brain) {
|
||||
try {
|
||||
await brain.shutdown()
|
||||
} catch (e) {
|
||||
// Ignore
|
||||
}
|
||||
}
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
testBasicFunctionality()
|
||||
89
tests/manual-tests/test-storage-augmentation.js
Normal file
89
tests/manual-tests/test-storage-augmentation.js
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
/**
|
||||
* Test script to verify storage augmentation system works
|
||||
*/
|
||||
|
||||
import { BrainyData } from './dist/brainyData.js'
|
||||
import {
|
||||
MemoryStorageAugmentation,
|
||||
FileSystemStorageAugmentation
|
||||
} from './dist/augmentations/storageAugmentations.js'
|
||||
|
||||
console.log('🧪 Testing Storage Augmentation System')
|
||||
console.log('=' .repeat(50))
|
||||
|
||||
async function test1_ZeroConfig() {
|
||||
console.log('\n1. Zero-Config Test')
|
||||
const brain = new BrainyData()
|
||||
await brain.init()
|
||||
|
||||
await brain.add('test', { content: 'Zero-config test' })
|
||||
const results = await brain.search('test', 1)
|
||||
|
||||
console.log('✅ Zero-config works:', results.length > 0)
|
||||
await brain.destroy()
|
||||
}
|
||||
|
||||
async function test2_ConfigBased() {
|
||||
console.log('\n2. Config-Based Storage Test')
|
||||
const brain = new BrainyData({
|
||||
storage: {
|
||||
forceMemoryStorage: true
|
||||
}
|
||||
})
|
||||
await brain.init()
|
||||
|
||||
await brain.add('config test', { content: 'Config-based test' })
|
||||
const results = await brain.search('config', 1)
|
||||
|
||||
console.log('✅ Config-based works:', results.length > 0)
|
||||
await brain.destroy()
|
||||
}
|
||||
|
||||
async function test3_AugmentationOverride() {
|
||||
console.log('\n3. Augmentation Override Test')
|
||||
const brain = new BrainyData()
|
||||
|
||||
// Register storage augmentation BEFORE init
|
||||
brain.augmentations.register(new MemoryStorageAugmentation('test-memory'))
|
||||
|
||||
await brain.init()
|
||||
|
||||
await brain.add('augmentation test', { content: 'Augmentation override test' })
|
||||
const results = await brain.search('augmentation', 1)
|
||||
|
||||
console.log('✅ Augmentation override works:', results.length > 0)
|
||||
await brain.destroy()
|
||||
}
|
||||
|
||||
async function test4_BackwardCompatibility() {
|
||||
console.log('\n4. Backward Compatibility Test')
|
||||
|
||||
// Old style with rootDirectory config
|
||||
const brain = new BrainyData({
|
||||
storage: {
|
||||
rootDirectory: './test-data',
|
||||
forceFileSystemStorage: true
|
||||
}
|
||||
})
|
||||
|
||||
await brain.init()
|
||||
console.log('✅ Backward compatible config works')
|
||||
await brain.destroy()
|
||||
}
|
||||
|
||||
async function runAllTests() {
|
||||
try {
|
||||
await test1_ZeroConfig()
|
||||
await test2_ConfigBased()
|
||||
await test3_AugmentationOverride()
|
||||
await test4_BackwardCompatibility()
|
||||
|
||||
console.log('\n' + '='.repeat(50))
|
||||
console.log('✅ ALL STORAGE AUGMENTATION TESTS PASSED!')
|
||||
} catch (error) {
|
||||
console.error('❌ Test failed:', error)
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
runAllTests()
|
||||
136
tests/manual-tests/test-with-8gb.js
Normal file
136
tests/manual-tests/test-with-8gb.js
Normal file
|
|
@ -0,0 +1,136 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Test Brainy with REAL search and embeddings
|
||||
* Requires 6-8GB RAM (ONNX runtime requirement)
|
||||
*/
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
import v8 from 'v8'
|
||||
|
||||
// Check if we have enough memory allocated
|
||||
const maxHeap = v8.getHeapStatistics().heap_size_limit / (1024 * 1024 * 1024)
|
||||
console.log(`🧠 Node.js heap limit: ${maxHeap.toFixed(1)}GB`)
|
||||
|
||||
if (maxHeap < 6) {
|
||||
console.error('⚠️ WARNING: Less than 6GB heap allocated')
|
||||
console.error('Please run with: NODE_OPTIONS="--max-old-space-size=8192" node test-with-8gb.js')
|
||||
console.error('Or use: npm run test:memory')
|
||||
}
|
||||
|
||||
console.log('\n🧪 Testing Brainy with REAL Search & Embeddings')
|
||||
console.log('='.repeat(50))
|
||||
|
||||
async function testRealSearch() {
|
||||
try {
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false
|
||||
})
|
||||
|
||||
console.log('\n1. Initializing Brainy...')
|
||||
await brain.init()
|
||||
console.log('✅ Initialized successfully')
|
||||
|
||||
// Add test data
|
||||
console.log('\n2. Adding test data...')
|
||||
const items = [
|
||||
{ name: 'JavaScript', type: 'programming language', year: 1995, paradigm: 'multi-paradigm' },
|
||||
{ name: 'Python', type: 'programming language', year: 1991, paradigm: 'object-oriented' },
|
||||
{ name: 'TypeScript', type: 'programming language', year: 2012, paradigm: 'typed' },
|
||||
{ name: 'React', type: 'library', year: 2013, language: 'JavaScript' },
|
||||
{ name: 'Vue', type: 'framework', year: 2014, language: 'JavaScript' },
|
||||
{ name: 'Django', type: 'framework', year: 2005, language: 'Python' },
|
||||
{ name: 'Node.js', type: 'runtime', year: 2009, language: 'JavaScript' }
|
||||
]
|
||||
|
||||
const ids = []
|
||||
for (const item of items) {
|
||||
const id = await brain.addNoun(item)
|
||||
ids.push(id)
|
||||
console.log(` Added: ${item.name}`)
|
||||
}
|
||||
console.log(`✅ Added ${ids.length} items`)
|
||||
|
||||
// Test 1: Semantic search
|
||||
console.log('\n3. Testing SEMANTIC SEARCH...')
|
||||
console.log(' Searching for "web development"...')
|
||||
const semanticResults = await brain.search('web development', 3)
|
||||
console.log(` ✅ Found ${semanticResults.length} semantic matches`)
|
||||
semanticResults.forEach(r => {
|
||||
console.log(` - ${r.metadata?.name || r.id} (score: ${r.score?.toFixed(3)})`)
|
||||
})
|
||||
|
||||
// Test 2: Natural language search
|
||||
console.log('\n4. Testing NATURAL LANGUAGE...')
|
||||
console.log(' Query: "JavaScript frameworks from recent years"')
|
||||
const nlpResults = await brain.find('JavaScript frameworks from recent years')
|
||||
console.log(` ✅ Found ${nlpResults.length} NLP matches`)
|
||||
nlpResults.forEach(r => {
|
||||
console.log(` - ${r.metadata?.name || r.id}`)
|
||||
})
|
||||
|
||||
// Test 3: Triple Intelligence with Brain Patterns
|
||||
console.log('\n5. Testing TRIPLE INTELLIGENCE with Brain Patterns...')
|
||||
console.log(' Query: Similar to "React", year > 2010, type = framework')
|
||||
const tripleResults = await brain.triple.search({
|
||||
like: 'React',
|
||||
where: {
|
||||
year: { greaterThan: 2010 },
|
||||
type: 'framework'
|
||||
},
|
||||
limit: 5
|
||||
})
|
||||
console.log(` ✅ Found ${tripleResults.length} triple matches`)
|
||||
tripleResults.forEach(r => {
|
||||
console.log(` - ${r.metadata?.name || r.id} (fusion score: ${r.fusionScore?.toFixed(3)})`)
|
||||
})
|
||||
|
||||
// Test 4: Range queries with metadata
|
||||
console.log('\n6. Testing RANGE QUERIES...')
|
||||
console.log(' Query: Languages from 1990-2000')
|
||||
const rangeResults = await brain.search('*', 10, {
|
||||
metadata: {
|
||||
year: { greaterThan: 1990, lessThan: 2000 },
|
||||
type: 'programming language'
|
||||
}
|
||||
})
|
||||
console.log(` ✅ Found ${rangeResults.length} range matches`)
|
||||
rangeResults.forEach(r => {
|
||||
console.log(` - ${r.metadata?.name} (${r.metadata?.year})`)
|
||||
})
|
||||
|
||||
// Memory check
|
||||
console.log('\n7. Memory Usage:')
|
||||
const mem = process.memoryUsage()
|
||||
console.log(` Heap Used: ${(mem.heapUsed / 1024 / 1024).toFixed(2)} MB`)
|
||||
console.log(` Heap Total: ${(mem.heapTotal / 1024 / 1024).toFixed(2)} MB`)
|
||||
console.log(` RSS: ${(mem.rss / 1024 / 1024).toFixed(2)} MB`)
|
||||
|
||||
// Success!
|
||||
console.log('\n' + '='.repeat(50))
|
||||
console.log('🎉 SUCCESS! All Brainy features working:')
|
||||
console.log('✅ Semantic Search (embeddings)')
|
||||
console.log('✅ Natural Language (NLP)')
|
||||
console.log('✅ Triple Intelligence')
|
||||
console.log('✅ Brain Patterns (range queries)')
|
||||
console.log('✅ Zero Configuration')
|
||||
console.log('\n📝 Note: Required ~4-6GB RAM for transformer model')
|
||||
console.log('This is normal and expected for AI features.')
|
||||
|
||||
process.exit(0)
|
||||
} catch (error) {
|
||||
console.error('\n❌ Test failed:', error.message)
|
||||
console.error(error.stack)
|
||||
|
||||
if (error.message.includes('heap') || error.message.includes('memory')) {
|
||||
console.error('\n💡 TIP: Increase memory allocation:')
|
||||
console.error('NODE_OPTIONS="--max-old-space-size=8192" node test-with-8gb.js')
|
||||
}
|
||||
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
// Run the test
|
||||
testRealSearch()
|
||||
156
tests/manual-tests/test-without-embeddings.js
Normal file
156
tests/manual-tests/test-without-embeddings.js
Normal file
|
|
@ -0,0 +1,156 @@
|
|||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Test ALL Brainy functionality EXCEPT embeddings/search
|
||||
* This validates core database operations without ONNX memory issues
|
||||
*/
|
||||
|
||||
import { BrainyData } from './dist/index.js'
|
||||
|
||||
console.log('🧠 Testing Brainy Core (No Embeddings)')
|
||||
console.log('=' + '='.repeat(50))
|
||||
|
||||
async function testCoreFeatures() {
|
||||
try {
|
||||
const brain = new BrainyData({
|
||||
storage: { forceMemoryStorage: true },
|
||||
verbose: false,
|
||||
// Disable embedding features for this test
|
||||
embeddingFunction: async (text) => {
|
||||
// Return fake embeddings - just for testing non-ML features
|
||||
return new Array(384).fill(0.1)
|
||||
}
|
||||
})
|
||||
|
||||
console.log('\n1. Initializing Brainy...')
|
||||
await brain.init()
|
||||
console.log('✅ Initialized')
|
||||
|
||||
// Test data with pre-computed vectors
|
||||
const items = [
|
||||
{
|
||||
name: 'JavaScript',
|
||||
type: 'language',
|
||||
year: 1995,
|
||||
vector: new Array(384).fill(0.1)
|
||||
},
|
||||
{
|
||||
name: 'TypeScript',
|
||||
type: 'language',
|
||||
year: 2012,
|
||||
vector: new Array(384).fill(0.2)
|
||||
},
|
||||
{
|
||||
name: 'React',
|
||||
type: 'framework',
|
||||
year: 2013,
|
||||
vector: new Array(384).fill(0.3)
|
||||
},
|
||||
{
|
||||
name: 'Vue',
|
||||
type: 'framework',
|
||||
year: 2014,
|
||||
vector: new Array(384).fill(0.4)
|
||||
}
|
||||
]
|
||||
|
||||
// 1. Test addNoun with vectors
|
||||
console.log('\n2. Testing addNoun with vectors...')
|
||||
const ids = []
|
||||
for (const item of items) {
|
||||
const id = await brain.addNoun(item)
|
||||
ids.push(id)
|
||||
}
|
||||
console.log('✅ Added', ids.length, 'items')
|
||||
|
||||
// 2. Test getNoun
|
||||
console.log('\n3. Testing getNoun...')
|
||||
const retrieved = await brain.getNoun(ids[0])
|
||||
console.log('✅ Retrieved:', retrieved?.metadata?.name || 'item')
|
||||
|
||||
// 3. Test updateNoun
|
||||
console.log('\n4. Testing updateNoun...')
|
||||
await brain.updateNoun(ids[0], { popularity: 'high' })
|
||||
const updated = await brain.getNoun(ids[0])
|
||||
console.log('✅ Updated with popularity:', updated?.metadata?.popularity)
|
||||
|
||||
// 4. Test metadata filtering (Brain Patterns)
|
||||
console.log('\n5. Testing Brain Patterns (metadata filtering)...')
|
||||
const filterResults = await brain.search('*', 10, {
|
||||
metadata: {
|
||||
type: 'framework',
|
||||
year: { greaterThan: 2012 }
|
||||
}
|
||||
})
|
||||
console.log('✅ Found', filterResults.length, 'frameworks after 2012')
|
||||
|
||||
// 5. Test range queries
|
||||
console.log('\n6. Testing range queries...')
|
||||
const rangeResults = await brain.search('*', 10, {
|
||||
metadata: {
|
||||
year: { greaterThan: 1990, lessThan: 2010 }
|
||||
}
|
||||
})
|
||||
console.log('✅ Found', rangeResults.length, 'items from 1990-2010')
|
||||
|
||||
// 6. Test getAllNouns
|
||||
console.log('\n7. Testing getAllNouns...')
|
||||
const allItems = await brain.getAllNouns()
|
||||
console.log('✅ Total items:', allItems.length)
|
||||
|
||||
// 7. Test deleteNoun
|
||||
console.log('\n8. Testing deleteNoun...')
|
||||
await brain.deleteNoun(ids[0])
|
||||
const afterDelete = await brain.getAllNouns()
|
||||
console.log('✅ After delete:', afterDelete.length, 'items')
|
||||
|
||||
// 8. Test clearAll
|
||||
console.log('\n9. Testing clearAll...')
|
||||
await brain.clearAll({ force: true })
|
||||
const afterClear = await brain.getAllNouns()
|
||||
console.log('✅ After clear:', afterClear.length, 'items')
|
||||
|
||||
// 9. Test batch operations
|
||||
console.log('\n10. Testing batch operations...')
|
||||
const batchIds = []
|
||||
for (let i = 0; i < 100; i++) {
|
||||
const id = await brain.addNoun({
|
||||
name: `Item ${i}`,
|
||||
index: i,
|
||||
vector: new Array(384).fill(i / 100)
|
||||
})
|
||||
batchIds.push(id)
|
||||
}
|
||||
console.log('✅ Added 100 items in batch')
|
||||
|
||||
// 10. Test statistics
|
||||
console.log('\n11. Testing statistics...')
|
||||
const stats = await brain.getStatistics()
|
||||
console.log('✅ Stats - Total items:', stats.totalItems)
|
||||
console.log(' Dimensions:', stats.dimensions)
|
||||
console.log(' Index size:', stats.indexSize)
|
||||
|
||||
// Memory usage
|
||||
console.log('\n12. Memory Usage:')
|
||||
const mem = process.memoryUsage()
|
||||
console.log(' Heap Used:', (mem.heapUsed / 1024 / 1024).toFixed(2), 'MB')
|
||||
console.log(' RSS:', (mem.rss / 1024 / 1024).toFixed(2), 'MB')
|
||||
|
||||
console.log('\n' + '='.repeat(51))
|
||||
console.log('🎉 SUCCESS! CORE FEATURES WORKING!')
|
||||
console.log('✅ CRUD Operations (add/get/update/delete)')
|
||||
console.log('✅ Metadata filtering (Brain Patterns)')
|
||||
console.log('✅ Range queries')
|
||||
console.log('✅ Batch operations')
|
||||
console.log('✅ Statistics')
|
||||
console.log('✅ Memory usage: <100MB (no ONNX)')
|
||||
|
||||
process.exit(0)
|
||||
} catch (error) {
|
||||
console.error('\n❌ Test failed:', error.message)
|
||||
console.error(error.stack)
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
testCoreFeatures()
|
||||
20
tests/scripts/fix-clear-in-tests.sh
Executable file
20
tests/scripts/fix-clear-in-tests.sh
Executable file
|
|
@ -0,0 +1,20 @@
|
|||
#!/bin/bash
|
||||
|
||||
# Fix all .clear() calls to .clearAll({ force: true }) in tests
|
||||
|
||||
echo "🔧 Fixing clear() calls in test files..."
|
||||
|
||||
# Find and replace in all test files
|
||||
for file in tests/*.test.ts; do
|
||||
if grep -q "\.clear()" "$file"; then
|
||||
echo " Fixing: $file"
|
||||
# Replace various patterns
|
||||
sed -i 's/\.clear()/\.clearAll({ force: true })/g' "$file"
|
||||
sed -i 's/\.clearAll({ force: true }) \/\/ Clear any existing data/\.clearAll({ force: true }) \/\/ Clear any existing data/g' "$file"
|
||||
fi
|
||||
done
|
||||
|
||||
echo "✅ Fixed all clear() calls to clearAll({ force: true })"
|
||||
echo ""
|
||||
echo "Files modified:"
|
||||
grep -l "clearAll({ force: true })" tests/*.test.ts | sed 's/^/ - /'
|
||||
97
tests/scripts/run-all-tests.sh
Executable file
97
tests/scripts/run-all-tests.sh
Executable file
|
|
@ -0,0 +1,97 @@
|
|||
#!/bin/bash
|
||||
|
||||
# Run all Brainy tests sequentially with memory management
|
||||
# This prevents memory exhaustion from parallel test execution
|
||||
|
||||
echo "🧠 Running Brainy 2.0 Complete Test Suite"
|
||||
echo "========================================"
|
||||
echo "Memory: 16GB allocated per test batch"
|
||||
echo ""
|
||||
|
||||
# Set Node options for all tests
|
||||
export NODE_OPTIONS='--max-old-space-size=16384'
|
||||
export BRAINY_MODELS_PATH=./models
|
||||
export BRAINY_ALLOW_REMOTE_MODELS=false
|
||||
|
||||
# Counter for tracking results
|
||||
PASSED=0
|
||||
FAILED=0
|
||||
SKIPPED=0
|
||||
TOTAL=0
|
||||
|
||||
# Run tests in batches to prevent memory exhaustion
|
||||
echo "📦 Batch 1: Core Tests"
|
||||
echo "----------------------"
|
||||
npm test -- --run tests/core.test.ts 2>&1 | tee batch1.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
echo "📦 Batch 2: Triple Intelligence & Neural"
|
||||
echo "----------------------------------------"
|
||||
npm test -- --run tests/triple-intelligence.test.ts tests/neural-api.test.ts 2>&1 | tee batch2.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
echo "📦 Batch 3: Metadata & Performance"
|
||||
echo "-----------------------------------"
|
||||
npm test -- --run tests/metadata-*.test.ts 2>&1 | tee batch3.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
echo "📦 Batch 4: Storage & Database"
|
||||
echo "-------------------------------"
|
||||
npm test -- --run tests/database-operations.test.ts tests/storage-adapter-coverage.test.ts 2>&1 | tee batch4.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
echo "📦 Batch 5: Augmentations"
|
||||
echo "-------------------------"
|
||||
npm test -- --run tests/augmentations-*.test.ts 2>&1 | tee batch5.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
echo "📦 Batch 6: API & Consistency"
|
||||
echo "-----------------------------"
|
||||
npm test -- --run tests/consistent-api.test.ts tests/unified-api.test.ts 2>&1 | tee batch6.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
echo "📦 Batch 7: Environment & Edge Cases"
|
||||
echo "-------------------------------------"
|
||||
npm test -- --run tests/environment.*.test.ts tests/edge-cases.test.ts 2>&1 | tee batch7.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
echo "📦 Batch 8: Find & NLP"
|
||||
echo "----------------------"
|
||||
npm test -- --run tests/find-comprehensive.test.ts tests/nlp-patterns-comprehensive.test.ts 2>&1 | tee batch8.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
echo "📦 Batch 9: Regression & Validation"
|
||||
echo "------------------------------------"
|
||||
npm test -- --run tests/regression.test.ts tests/release-*.test.ts 2>&1 | tee batch9.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
echo "📦 Batch 10: Other Tests"
|
||||
echo "------------------------"
|
||||
npm test -- --run tests/distributed*.test.ts tests/cli.test.ts tests/brainy-chat.test.ts tests/pagination.test.ts tests/vector-operations.test.ts tests/error-handling.test.ts tests/specialized-scenarios.test.ts tests/multi-environment.test.ts tests/statistics.test.ts tests/type-utils.test.ts 2>&1 | tee batch10.log | grep -E "✓|×|↓" | tail -20
|
||||
echo ""
|
||||
|
||||
# Aggregate results
|
||||
echo ""
|
||||
echo "=========================================="
|
||||
echo "🎯 FINAL TEST RESULTS"
|
||||
echo "=========================================="
|
||||
|
||||
# Count passed/failed from all logs
|
||||
PASSED=$(cat batch*.log 2>/dev/null | grep -c "✓" || echo 0)
|
||||
FAILED=$(cat batch*.log 2>/dev/null | grep -c "×" || echo 0)
|
||||
SKIPPED=$(cat batch*.log 2>/dev/null | grep -c "↓" || echo 0)
|
||||
TOTAL=$((PASSED + FAILED + SKIPPED))
|
||||
|
||||
echo "✅ Passed: $PASSED"
|
||||
echo "❌ Failed: $FAILED"
|
||||
echo "⏭️ Skipped: $SKIPPED"
|
||||
echo "📊 Total: $TOTAL"
|
||||
echo ""
|
||||
|
||||
if [ $FAILED -eq 0 ]; then
|
||||
echo "🎉 SUCCESS! All tests passed!"
|
||||
exit 0
|
||||
else
|
||||
echo "⚠️ Some tests failed. Check individual batch logs for details."
|
||||
exit 1
|
||||
fi
|
||||
111
tests/scripts/run-tests-safe.sh
Executable file
111
tests/scripts/run-tests-safe.sh
Executable file
|
|
@ -0,0 +1,111 @@
|
|||
#!/bin/bash
|
||||
|
||||
# Safe test runner with memory management
|
||||
# Runs tests in groups to avoid OOM errors
|
||||
|
||||
echo "🧠 Brainy Test Runner - Memory Safe Mode"
|
||||
echo "========================================="
|
||||
|
||||
# Set environment variables
|
||||
export BRAINY_MODELS_PATH=./models
|
||||
export BRAINY_ALLOW_REMOTE_MODELS=false
|
||||
export NODE_OPTIONS="--max-old-space-size=2048"
|
||||
|
||||
# Track results
|
||||
TOTAL_PASSED=0
|
||||
TOTAL_FAILED=0
|
||||
FAILED_TESTS=""
|
||||
|
||||
# Function to run a test group
|
||||
run_test_group() {
|
||||
local group_name=$1
|
||||
local test_pattern=$2
|
||||
|
||||
echo ""
|
||||
echo "📊 Running: $group_name"
|
||||
echo "----------------------------------------"
|
||||
|
||||
# Run tests and capture output
|
||||
if npx vitest run $test_pattern --reporter=verbose 2>&1 | tee test-output.tmp | grep -E "(Test Files|Tests)" | tail -2; then
|
||||
# Extract pass/fail counts
|
||||
local result=$(tail -2 test-output.tmp | grep -E "(passed|failed)")
|
||||
echo "$result"
|
||||
|
||||
# Parse results (basic parsing, might need adjustment)
|
||||
if echo "$result" | grep -q "failed"; then
|
||||
FAILED_TESTS="$FAILED_TESTS\n - $group_name"
|
||||
((TOTAL_FAILED++))
|
||||
else
|
||||
((TOTAL_PASSED++))
|
||||
fi
|
||||
else
|
||||
echo " ❌ Test group failed to run"
|
||||
FAILED_TESTS="$FAILED_TESTS\n - $group_name (crashed)"
|
||||
((TOTAL_FAILED++))
|
||||
fi
|
||||
|
||||
# Clean up temp file
|
||||
rm -f test-output.tmp
|
||||
|
||||
# Force garbage collection pause
|
||||
sleep 2
|
||||
}
|
||||
|
||||
# Run test groups
|
||||
echo "🚀 Starting test execution..."
|
||||
|
||||
# Group 1: Core functionality
|
||||
run_test_group "Core API Tests" "tests/core.test.ts tests/consistent-api.test.ts tests/unified-api.test.ts"
|
||||
|
||||
# Group 2: Intelligent features
|
||||
run_test_group "Intelligent Features" "tests/intelligent-verb-scoring.test.ts tests/neural-import.test.ts tests/neural-clustering.test.ts"
|
||||
|
||||
# Group 3: Augmentations
|
||||
run_test_group "Augmentations" "tests/augmentations-*.test.ts"
|
||||
|
||||
# Group 4: Storage
|
||||
run_test_group "Storage Adapters" "tests/storage-adapter-coverage.test.ts tests/opfs-storage.test.ts"
|
||||
|
||||
# Group 5: Vector operations
|
||||
run_test_group "Vector Operations" "tests/vector-operations.test.ts tests/dimension-standardization.test.ts"
|
||||
|
||||
# Group 6: Triple Intelligence
|
||||
run_test_group "Triple Intelligence" "tests/triple-intelligence.test.ts tests/metadata-filter.test.ts"
|
||||
|
||||
# Group 7: Performance (lighter tests)
|
||||
run_test_group "Performance Tests" "tests/performance.test.ts tests/pagination.test.ts"
|
||||
|
||||
# Group 8: Edge cases
|
||||
run_test_group "Edge Cases & Error Handling" "tests/edge-cases.test.ts tests/error-handling.test.ts"
|
||||
|
||||
# Group 9: Zero config
|
||||
run_test_group "Zero Config" "tests/zero-config-models.test.ts tests/auto-configuration.test.ts"
|
||||
|
||||
# Group 10: Model loading
|
||||
run_test_group "Model Loading" "tests/model-loading.test.ts"
|
||||
|
||||
# Summary
|
||||
echo ""
|
||||
echo "========================================="
|
||||
echo "📈 TEST SUMMARY"
|
||||
echo "========================================="
|
||||
echo "✅ Passed: $TOTAL_PASSED test groups"
|
||||
echo "❌ Failed: $TOTAL_FAILED test groups"
|
||||
|
||||
if [ ! -z "$FAILED_TESTS" ]; then
|
||||
echo ""
|
||||
echo "Failed groups:"
|
||||
echo -e "$FAILED_TESTS"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "========================================="
|
||||
|
||||
# Exit with appropriate code
|
||||
if [ $TOTAL_FAILED -gt 0 ]; then
|
||||
echo "❌ Tests failed. Please fix before release."
|
||||
exit 1
|
||||
else
|
||||
echo "✅ All test groups passed!"
|
||||
exit 0
|
||||
fi
|
||||
73
tests/scripts/test-all-with-memory.sh
Executable file
73
tests/scripts/test-all-with-memory.sh
Executable file
|
|
@ -0,0 +1,73 @@
|
|||
#!/bin/bash
|
||||
|
||||
# Comprehensive test runner with proper memory management
|
||||
# Runs ALL tests with adequate memory allocation
|
||||
|
||||
echo "🧠 Brainy 2.0 Complete Test Suite with Memory Management"
|
||||
echo "========================================================="
|
||||
echo ""
|
||||
|
||||
# Set environment for ALL tests
|
||||
export NODE_OPTIONS='--max-old-space-size=16384'
|
||||
export BRAINY_MODELS_PATH=./models
|
||||
export BRAINY_ALLOW_REMOTE_MODELS=false
|
||||
|
||||
# Use our memory-optimized vitest config
|
||||
export VITEST_CONFIG=./vitest.config.memory.ts
|
||||
|
||||
echo "📊 Configuration:"
|
||||
echo " - Node heap: 16GB"
|
||||
echo " - Models: Local only"
|
||||
echo " - Tests: Sequential execution"
|
||||
echo " - Timeout: 2 minutes per test"
|
||||
echo ""
|
||||
|
||||
# Build first
|
||||
echo "🔨 Building TypeScript..."
|
||||
npm run build
|
||||
if [ $? -ne 0 ]; then
|
||||
echo "❌ Build failed! Fix TypeScript errors first."
|
||||
exit 1
|
||||
fi
|
||||
echo "✅ Build successful"
|
||||
echo ""
|
||||
|
||||
# Run all tests with memory config
|
||||
echo "🧪 Running all tests..."
|
||||
npm test -- --config ./vitest.config.memory.ts --reporter=verbose 2>&1 | tee full-test-output.log
|
||||
|
||||
# Extract summary
|
||||
echo ""
|
||||
echo "=========================================="
|
||||
echo "📊 Test Summary"
|
||||
echo "=========================================="
|
||||
|
||||
# Count results
|
||||
PASSED=$(grep -c "✓" full-test-output.log 2>/dev/null || echo 0)
|
||||
FAILED=$(grep -c "×" full-test-output.log 2>/dev/null || echo 0)
|
||||
SKIPPED=$(grep -c "↓" full-test-output.log 2>/dev/null || echo 0)
|
||||
|
||||
echo "✅ Passed: $PASSED"
|
||||
echo "❌ Failed: $FAILED"
|
||||
echo "⏭️ Skipped: $SKIPPED"
|
||||
echo "📊 Total: $((PASSED + FAILED + SKIPPED))"
|
||||
echo ""
|
||||
|
||||
if [ $FAILED -eq 0 ]; then
|
||||
echo "🎉 SUCCESS! All tests passed!"
|
||||
echo ""
|
||||
echo "Ready for release:"
|
||||
echo " npm version patch"
|
||||
echo " npm publish"
|
||||
exit 0
|
||||
else
|
||||
echo "⚠️ $FAILED tests failed."
|
||||
echo ""
|
||||
echo "Common issues:"
|
||||
echo "1. Out of memory → Increase NODE_OPTIONS"
|
||||
echo "2. Timeout → Tests need more than 2 minutes"
|
||||
echo "3. clearAll → Must use { force: true }"
|
||||
echo ""
|
||||
echo "Check full-test-output.log for details."
|
||||
exit 1
|
||||
fi
|
||||
Loading…
Add table
Add a link
Reference in a new issue