genesis-ai-cli 7.4.5

package/dist/test/brain.test.js

@@ -0,0 +1,358 @@
+"use strict";
+/**
+ * Tests for Brain Module (Phase 10: Neural Integration Layer)
+ *
+ * Tests the Cognitive Integration Layer:
+ * - Command routing (Supervisor pattern)
+ * - State management
+ * - Module transitions
+ * - Metrics tracking
+ * - Event system
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+(0, node_test_1.describe)('Brain Module (Phase 10)', () => {
+    (0, node_test_1.describe)('Brain Types', () => {
+        (0, node_test_1.test)('exports all required types', async () => {
+            const types = await import('../src/brain/types.js');
+            // Check type exports exist
+            node_assert_1.default.ok(types.DEFAULT_BRAIN_CONFIG, 'DEFAULT_BRAIN_CONFIG should exist');
+            node_assert_1.default.strictEqual(typeof types.DEFAULT_BRAIN_CONFIG, 'object');
+        });
+        (0, node_test_1.test)('DEFAULT_BRAIN_CONFIG has correct structure', async () => {
+            const { DEFAULT_BRAIN_CONFIG } = await import('../src/brain/types.js');
+            // Memory config
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.memory.enabled, 'boolean');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.memory.anticipationEnabled, 'boolean');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.memory.maxContextTokens, 'number');
+            // LLM config
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.llm.enabled, 'boolean');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.llm.maxRetries, 'number');
+            // Grounding config
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.grounding.enabled, 'boolean');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.grounding.verifyAllResponses, 'boolean');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.grounding.confidenceThreshold, 'number');
+            // Tools config
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.tools.enabled, 'boolean');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.tools.maxExecutions, 'number');
+            // Healing config
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.healing.enabled, 'boolean');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.healing.maxAttempts, 'number');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.healing.autoHeal, 'boolean');
+            // Consciousness config
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.consciousness.enabled, 'boolean');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.consciousness.phiThreshold, 'number');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.consciousness.broadcastEnabled, 'boolean');
+            // Processing limits
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.maxCycleTime, 'number');
+            node_assert_1.default.strictEqual(typeof DEFAULT_BRAIN_CONFIG.maxModuleTransitions, 'number');
+        });
+        (0, node_test_1.test)('DEFAULT_BRAIN_CONFIG has sensible defaults', async () => {
+            const { DEFAULT_BRAIN_CONFIG } = await import('../src/brain/types.js');
+            // Memory should be enabled by default
+            node_assert_1.default.strictEqual(DEFAULT_BRAIN_CONFIG.memory.enabled, true);
+            // Context tokens should be reasonable (8K default)
+            node_assert_1.default.ok(DEFAULT_BRAIN_CONFIG.memory.maxContextTokens >= 1000);
+            node_assert_1.default.ok(DEFAULT_BRAIN_CONFIG.memory.maxContextTokens <= 128000);
+            // Grounding confidence threshold should be between 0 and 1
+            node_assert_1.default.ok(DEFAULT_BRAIN_CONFIG.grounding.confidenceThreshold >= 0);
+            node_assert_1.default.ok(DEFAULT_BRAIN_CONFIG.grounding.confidenceThreshold <= 1);
+            // Max cycle time should be reasonable (not infinite)
+            node_assert_1.default.ok(DEFAULT_BRAIN_CONFIG.maxCycleTime > 0);
+            node_assert_1.default.ok(DEFAULT_BRAIN_CONFIG.maxCycleTime <= 600000); // Max 10 minutes
+            // Max transitions should prevent infinite loops
+            node_assert_1.default.ok(DEFAULT_BRAIN_CONFIG.maxModuleTransitions > 0);
+            node_assert_1.default.ok(DEFAULT_BRAIN_CONFIG.maxModuleTransitions <= 100);
+        });
+    });
+    (0, node_test_1.describe)('Brain Class', () => {
+        (0, node_test_1.test)('creates brain instance', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            node_assert_1.default.ok(brain, 'Brain should be created');
+        });
+        (0, node_test_1.test)('getBrain returns singleton', async () => {
+            const { getBrain, resetBrain } = await import('../src/brain/index.js');
+            // Reset first to ensure clean state
+            resetBrain();
+            const brain1 = getBrain();
+            const brain2 = getBrain();
+            node_assert_1.default.strictEqual(brain1, brain2, 'getBrain should return same instance');
+        });
+        (0, node_test_1.test)('resetBrain creates new instance', async () => {
+            const { getBrain, resetBrain } = await import('../src/brain/index.js');
+            const brain1 = getBrain();
+            resetBrain();
+            const brain2 = getBrain();
+            node_assert_1.default.notStrictEqual(brain1, brain2, 'resetBrain should create new instance');
+        });
+        (0, node_test_1.test)('brain has start/stop methods', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            node_assert_1.default.strictEqual(typeof brain.start, 'function');
+            node_assert_1.default.strictEqual(typeof brain.stop, 'function');
+        });
+        (0, node_test_1.test)('brain has isRunning method', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            node_assert_1.default.strictEqual(typeof brain.isRunning, 'function');
+            // Initially not running
+            node_assert_1.default.strictEqual(brain.isRunning(), false);
+            // Start and check
+            brain.start();
+            node_assert_1.default.strictEqual(brain.isRunning(), true);
+            // Stop and check
+            brain.stop();
+            node_assert_1.default.strictEqual(brain.isRunning(), false);
+        });
+        (0, node_test_1.test)('brain has process method', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            node_assert_1.default.strictEqual(typeof brain.process, 'function');
+        });
+        (0, node_test_1.test)('brain has getMetrics method', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            node_assert_1.default.strictEqual(typeof brain.getMetrics, 'function');
+            const metrics = brain.getMetrics();
+            node_assert_1.default.strictEqual(typeof metrics, 'object');
+        });
+    });
+    (0, node_test_1.describe)('Brain Metrics', () => {
+        (0, node_test_1.test)('initial metrics are zeroed', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            const metrics = brain.getMetrics();
+            node_assert_1.default.strictEqual(metrics.totalCycles, 0);
+            node_assert_1.default.strictEqual(metrics.successfulCycles, 0);
+            node_assert_1.default.strictEqual(metrics.failedCycles, 0);
+            node_assert_1.default.strictEqual(metrics.memoryRecalls, 0);
+            node_assert_1.default.strictEqual(metrics.groundingChecks, 0);
+            node_assert_1.default.strictEqual(metrics.toolExecutions, 0);
+            node_assert_1.default.strictEqual(metrics.healingAttempts, 0);
+            node_assert_1.default.strictEqual(metrics.broadcasts, 0);
+        });
+        (0, node_test_1.test)('metrics track avgPhi', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            const metrics = brain.getMetrics();
+            node_assert_1.default.strictEqual(typeof metrics.avgPhi, 'number');
+            node_assert_1.default.ok(metrics.avgPhi >= 0, 'avgPhi should be >= 0');
+            node_assert_1.default.ok(metrics.avgPhi <= 1, 'avgPhi should be <= 1');
+        });
+        (0, node_test_1.test)('metrics track memoryReuseRate', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            const metrics = brain.getMetrics();
+            node_assert_1.default.strictEqual(typeof metrics.memoryReuseRate, 'number');
+            node_assert_1.default.ok(metrics.memoryReuseRate >= 0, 'memoryReuseRate should be >= 0');
+            node_assert_1.default.ok(metrics.memoryReuseRate <= 1, 'memoryReuseRate should be <= 1');
+        });
+        (0, node_test_1.test)('metrics have moduleTransitions', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            const metrics = brain.getMetrics();
+            node_assert_1.default.strictEqual(typeof metrics.moduleTransitions, 'object');
+        });
+    });
+    (0, node_test_1.describe)('Brain Events', () => {
+        (0, node_test_1.test)('brain has on method for events', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            node_assert_1.default.strictEqual(typeof brain.on, 'function');
+        });
+        (0, node_test_1.test)('on returns unsubscribe function', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            const events = [];
+            const handler = (event) => {
+                events.push(event.type);
+            };
+            // on() returns an unsubscribe function
+            const unsubscribe = brain.on(handler);
+            node_assert_1.default.strictEqual(typeof unsubscribe, 'function');
+            // Unsubscribe should not throw
+            unsubscribe();
+        });
+    });
+    (0, node_test_1.describe)('Brain Configuration', () => {
+        (0, node_test_1.test)('can create brain with custom config', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain({
+                memory: {
+                    enabled: false,
+                    anticipationEnabled: false,
+                    maxContextTokens: 4096,
+                },
+                llm: {
+                    enabled: true,
+                    maxRetries: 1,
+                },
+                grounding: {
+                    enabled: false,
+                    verifyAllResponses: false,
+                    confidenceThreshold: 0.8,
+                },
+                tools: {
+                    enabled: false,
+                    maxExecutions: 3,
+                },
+                healing: {
+                    enabled: false,
+                    maxAttempts: 1,
+                    autoHeal: false,
+                },
+                consciousness: {
+                    enabled: false,
+                    phiThreshold: 0.2,
+                    broadcastEnabled: false,
+                },
+                maxCycleTime: 30000,
+                maxModuleTransitions: 10,
+            });
+            node_assert_1.default.ok(brain, 'Brain should be created with custom config');
+        });
+    });
+    (0, node_test_1.describe)('Command Routing', () => {
+        (0, node_test_1.test)('BrainModule type includes all modules', async () => {
+            // This is a type-level test - we just verify the module works
+            const { DEFAULT_BRAIN_CONFIG } = await import('../src/brain/types.js');
+            // The modules are: memory, llm, grounding, tools, healing, consciousness, kernel, done
+            // If this compiles, the types are correct
+            const modules = ['memory', 'llm', 'grounding', 'tools', 'healing', 'consciousness', 'kernel', 'done'];
+            node_assert_1.default.strictEqual(modules.length, 8, 'Should have 8 modules');
+        });
+    });
+    (0, node_test_1.describe)('Integration', () => {
+        (0, node_test_1.test)('brain can be started and stopped multiple times', async () => {
+            const { createBrain } = await import('../src/brain/index.js');
+            const brain = createBrain();
+            // Start
+            brain.start();
+            node_assert_1.default.strictEqual(brain.isRunning(), true);
+            // Stop
+            brain.stop();
+            node_assert_1.default.strictEqual(brain.isRunning(), false);
+            // Start again
+            brain.start();
+            node_assert_1.default.strictEqual(brain.isRunning(), true);
+            // Stop again
+            brain.stop();
+            node_assert_1.default.strictEqual(brain.isRunning(), false);
+        });
+    });
+});
+(0, node_test_1.describe)('Brain Types Validation', () => {
+    (0, node_test_1.test)('BrainState interface fields', async () => {
+        // This tests the structure by creating a mock state
+        const mockState = {
+            query: 'test query',
+            context: {
+                immediate: [],
+                task: [],
+                episodic: [],
+                semantic: [],
+                formatted: '',
+                tokenEstimate: 0,
+                reuseRate: 0,
+            },
+            response: '',
+            toolCalls: [],
+            toolResults: [],
+            phi: 0,
+            ignited: false,
+            verified: false,
+            healingAttempts: 0,
+            startTime: Date.now(),
+            moduleHistory: [],
+        };
+        node_assert_1.default.strictEqual(typeof mockState.query, 'string');
+        node_assert_1.default.strictEqual(typeof mockState.context, 'object');
+        node_assert_1.default.strictEqual(typeof mockState.response, 'string');
+        node_assert_1.default.ok(Array.isArray(mockState.toolCalls));
+        node_assert_1.default.ok(Array.isArray(mockState.toolResults));
+        node_assert_1.default.strictEqual(typeof mockState.phi, 'number');
+        node_assert_1.default.strictEqual(typeof mockState.ignited, 'boolean');
+        node_assert_1.default.strictEqual(typeof mockState.verified, 'boolean');
+        node_assert_1.default.strictEqual(typeof mockState.healingAttempts, 'number');
+        node_assert_1.default.strictEqual(typeof mockState.startTime, 'number');
+        node_assert_1.default.ok(Array.isArray(mockState.moduleHistory));
+    });
+    (0, node_test_1.test)('Command interface structure', async () => {
+        // Test Command interface structure
+        const mockCommand = {
+            goto: 'llm',
+            update: { response: 'test' },
+            reason: 'Test transition',
+        };
+        node_assert_1.default.strictEqual(typeof mockCommand.goto, 'string');
+        node_assert_1.default.strictEqual(typeof mockCommand.update, 'object');
+        node_assert_1.default.strictEqual(typeof mockCommand.reason, 'string');
+    });
+    (0, node_test_1.test)('BrainContext interface structure', async () => {
+        const mockContext = {
+            immediate: [],
+            task: [],
+            episodic: [],
+            semantic: [],
+            formatted: '',
+            tokenEstimate: 0,
+            reuseRate: 0,
+        };
+        node_assert_1.default.ok(Array.isArray(mockContext.immediate));
+        node_assert_1.default.ok(Array.isArray(mockContext.task));
+        node_assert_1.default.ok(Array.isArray(mockContext.episodic));
+        node_assert_1.default.ok(Array.isArray(mockContext.semantic));
+        node_assert_1.default.strictEqual(typeof mockContext.formatted, 'string');
+        node_assert_1.default.strictEqual(typeof mockContext.tokenEstimate, 'number');
+        node_assert_1.default.strictEqual(typeof mockContext.reuseRate, 'number');
+    });
+});
+(0, node_test_1.describe)('Brain Trace (Phase 10)', () => {
+    (0, node_test_1.test)('createBrainTrace creates trace instance', async () => {
+        const { createBrain, createBrainTrace } = await import('../src/brain/index.js');
+        const brain = createBrain();
+        const trace = createBrainTrace(brain);
+        node_assert_1.default.ok(trace, 'Trace should be created');
+    });
+    (0, node_test_1.test)('trace has enable/disable methods', async () => {
+        const { createBrain, createBrainTrace } = await import('../src/brain/index.js');
+        const brain = createBrain();
+        const trace = createBrainTrace(brain);
+        node_assert_1.default.strictEqual(typeof trace.enable, 'function');
+        node_assert_1.default.strictEqual(typeof trace.disable, 'function');
+        node_assert_1.default.strictEqual(typeof trace.isEnabled, 'function');
+        node_assert_1.default.strictEqual(typeof trace.toggle, 'function');
+    });
+    (0, node_test_1.test)('trace starts disabled', async () => {
+        const { createBrain, createBrainTrace } = await import('../src/brain/index.js');
+        const brain = createBrain();
+        const trace = createBrainTrace(brain);
+        node_assert_1.default.strictEqual(trace.isEnabled(), false);
+    });
+    (0, node_test_1.test)('enable() enables trace', async () => {
+        const { createBrain, createBrainTrace } = await import('../src/brain/index.js');
+        const brain = createBrain();
+        const trace = createBrainTrace(brain);
+        trace.enable();
+        node_assert_1.default.strictEqual(trace.isEnabled(), true);
+        trace.disable();
+        node_assert_1.default.strictEqual(trace.isEnabled(), false);
+    });
+    (0, node_test_1.test)('toggle() toggles trace state', async () => {
+        const { createBrain, createBrainTrace } = await import('../src/brain/index.js');
+        const brain = createBrain();
+        const trace = createBrainTrace(brain);
+        node_assert_1.default.strictEqual(trace.isEnabled(), false);
+        const result1 = trace.toggle();
+        node_assert_1.default.strictEqual(result1, true);
+        node_assert_1.default.strictEqual(trace.isEnabled(), true);
+        const result2 = trace.toggle();
+        node_assert_1.default.strictEqual(result2, false);
+        node_assert_1.default.strictEqual(trace.isEnabled(), false);
+    });
+});

package/dist/test/cli/dispatcher.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Genesis Tool Dispatcher
+ */
+export {};