genesis-ai-cli 7.4.5

package/dist/test/healing/fixer.test.js

@@ -0,0 +1,369 @@
+"use strict";
+/**
+ * Tests for Genesis Auto-Fix Engine
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fixer_js_1 = require("../../src/healing/fixer.js");
+// Test directory
+const TEST_DIR = '/tmp/genesis-fixer-test-' + Date.now();
+(0, node_test_1.describe)('AutoFixer', () => {
+    (0, node_test_1.before)(() => {
+        fs.mkdirSync(TEST_DIR, { recursive: true });
+        (0, fixer_js_1.resetAutoFixer)();
+    });
+    (0, node_test_1.after)(() => {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+        (0, fixer_js_1.resetAutoFixer)();
+    });
+    (0, node_test_1.beforeEach)(() => {
+        // Clean test directory
+        const files = fs.readdirSync(TEST_DIR);
+        for (const file of files) {
+            fs.rmSync(path.join(TEST_DIR, file), { force: true, recursive: true });
+        }
+    });
+    // ==========================================================================
+    // Candidate Generation Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Candidate Generation', () => {
+        (0, node_test_1.it)('should generate fix for missing semicolon', async () => {
+            const filePath = path.join(TEST_DIR, 'semicolon.ts');
+            fs.writeFileSync(filePath, 'const x = 1\nconst y = 2;');
+            const error = {
+                category: 'syntax',
+                severity: 'error',
+                message: 'Missing semicolon',
+                file: filePath,
+                line: 1,
+                raw: 'Missing semicolon',
+                fixHint: 'syntax_fix',
+            };
+            const candidates = await (0, fixer_js_1.generateFixes)(error);
+            node_assert_1.default.ok(candidates.length > 0);
+            node_assert_1.default.ok(candidates.some(c => c.fixed.includes('const x = 1;')));
+        });
+        (0, node_test_1.it)('should generate fix for undefined variable', async () => {
+            const filePath = path.join(TEST_DIR, 'undefined.ts');
+            fs.writeFileSync(filePath, 'console.log(myVar);');
+            const error = {
+                category: 'runtime',
+                severity: 'error',
+                message: "'myVar' is not defined",
+                file: filePath,
+                line: 1,
+                raw: "'myVar' is not defined",
+                fixHint: 'runtime_error',
+            };
+            const candidates = await (0, fixer_js_1.generateFixes)(error);
+            node_assert_1.default.ok(candidates.length > 0);
+            node_assert_1.default.ok(candidates.some(c => c.fixed.includes('let myVar')));
+        });
+        (0, node_test_1.it)('should generate npm install for missing module', async () => {
+            const error = {
+                category: 'dependency',
+                severity: 'error',
+                message: "Cannot find module 'lodash'",
+                file: 'src/index.ts',
+                raw: "Cannot find module 'lodash'",
+                fixHint: 'install_dependency',
+            };
+            const candidates = await (0, fixer_js_1.generateFixes)(error);
+            node_assert_1.default.ok(candidates.length > 0);
+            node_assert_1.default.ok(candidates.some(c => c.fixed.includes('npm install lodash')));
+        });
+        (0, node_test_1.it)('should generate optional chaining for null checks', async () => {
+            const filePath = path.join(TEST_DIR, 'null.ts');
+            fs.writeFileSync(filePath, 'const x = obj.prop.value;');
+            const error = {
+                category: 'type',
+                severity: 'error',
+                message: "'obj' is possibly 'null'",
+                file: filePath,
+                line: 1,
+                raw: "'obj' is possibly 'null'",
+                fixHint: 'type_mismatch',
+            };
+            const candidates = await (0, fixer_js_1.generateFixes)(error);
+            // Should have optional chaining candidate
+            node_assert_1.default.ok(candidates.some(c => c.fixed.includes('?.') || c.fixed.includes('if (obj)')));
+        });
+        (0, node_test_1.it)('should not generate candidates for errors without file', async () => {
+            const error = {
+                category: 'runtime',
+                severity: 'error',
+                message: 'Some error',
+                raw: 'Some error',
+            };
+            const candidates = await (0, fixer_js_1.generateFixes)(error);
+            node_assert_1.default.strictEqual(candidates.length, 0);
+        });
+        (0, node_test_1.it)('should not generate candidates for non-existent files', async () => {
+            const error = {
+                category: 'syntax',
+                severity: 'error',
+                message: 'Missing semicolon',
+                file: '/nonexistent/file.ts',
+                line: 1,
+                raw: 'Missing semicolon',
+            };
+            const candidates = await (0, fixer_js_1.generateFixes)(error);
+            node_assert_1.default.strictEqual(candidates.length, 0);
+        });
+    });
+    // ==========================================================================
+    // Candidate Properties Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Candidate Properties', () => {
+        (0, node_test_1.it)('should have unique IDs', async () => {
+            const filePath = path.join(TEST_DIR, 'ids.ts');
+            fs.writeFileSync(filePath, 'const x = obj.value');
+            const error = {
+                category: 'type',
+                severity: 'error',
+                message: "'obj' is possibly 'null'",
+                file: filePath,
+                line: 1,
+                raw: 'possibly null',
+            };
+            const candidates = await (0, fixer_js_1.generateFixes)(error);
+            const ids = candidates.map(c => c.id);
+            const uniqueIds = new Set(ids);
+            node_assert_1.default.strictEqual(ids.length, uniqueIds.size);
+        });
+        (0, node_test_1.it)('should include confidence scores', async () => {
+            const filePath = path.join(TEST_DIR, 'conf.ts');
+            fs.writeFileSync(filePath, 'const x = 1');
+            const error = {
+                category: 'syntax',
+                severity: 'error',
+                message: 'Missing semicolon',
+                file: filePath,
+                line: 1,
+                raw: 'Missing semicolon',
+            };
+            const candidates = await (0, fixer_js_1.generateFixes)(error);
+            for (const candidate of candidates) {
+                node_assert_1.default.ok(candidate.confidence >= 0);
+                node_assert_1.default.ok(candidate.confidence <= 1);
+            }
+        });
+        (0, node_test_1.it)('should include source type', async () => {
+            const filePath = path.join(TEST_DIR, 'source.ts');
+            fs.writeFileSync(filePath, 'const x = 1');
+            const error = {
+                category: 'syntax',
+                severity: 'error',
+                message: 'Missing semicolon',
+                file: filePath,
+                line: 1,
+                raw: 'Missing semicolon',
+            };
+            const candidates = await (0, fixer_js_1.generateFixes)(error);
+            for (const candidate of candidates) {
+                node_assert_1.default.ok(['pattern', 'llm', 'heuristic'].includes(candidate.source));
+            }
+        });
+    });
+    // ==========================================================================
+    // Selection Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Selection', () => {
+        (0, node_test_1.it)('should select candidate with highest score', () => {
+            const fixer = (0, fixer_js_1.getAutoFixer)();
+            const evaluations = [
+                { candidate: { id: 'a' }, score: 0.5, testsPass: false, testsPassed: 0, testsTotal: 1, buildSuccess: true, newErrors: [], fixedErrors: [] },
+                { candidate: { id: 'b' }, score: 0.9, testsPass: true, testsPassed: 1, testsTotal: 1, buildSuccess: true, newErrors: [], fixedErrors: [] },
+                { candidate: { id: 'c' }, score: 0.3, testsPass: false, testsPassed: 0, testsTotal: 1, buildSuccess: false, newErrors: [], fixedErrors: [] },
+            ];
+            const best = fixer.selectBest(evaluations);
+            node_assert_1.default.ok(best);
+            node_assert_1.default.strictEqual(best.candidate.id, 'b');
+        });
+        (0, node_test_1.it)('should return null for empty evaluations', () => {
+            const fixer = (0, fixer_js_1.getAutoFixer)();
+            const best = fixer.selectBest([]);
+            node_assert_1.default.strictEqual(best, null);
+        });
+    });
+    // ==========================================================================
+    // Configuration Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Configuration', () => {
+        (0, node_test_1.it)('should use default configuration', () => {
+            const fixer = new fixer_js_1.AutoFixer();
+            const config = fixer.getConfig();
+            node_assert_1.default.strictEqual(config.maxCandidates, 5);
+            node_assert_1.default.strictEqual(config.maxIterations, 3);
+            node_assert_1.default.strictEqual(config.createBackup, true);
+        });
+        (0, node_test_1.it)('should accept custom configuration', () => {
+            const fixer = new fixer_js_1.AutoFixer({
+                maxCandidates: 10,
+                maxIterations: 5,
+                testCommand: 'npm run test:unit',
+            });
+            const config = fixer.getConfig();
+            node_assert_1.default.strictEqual(config.maxCandidates, 10);
+            node_assert_1.default.strictEqual(config.maxIterations, 5);
+            node_assert_1.default.strictEqual(config.testCommand, 'npm run test:unit');
+        });
+        (0, node_test_1.it)('should update configuration', () => {
+            const fixer = (0, fixer_js_1.getAutoFixer)();
+            fixer.updateConfig({ maxIterations: 10 });
+            const config = fixer.getConfig();
+            node_assert_1.default.strictEqual(config.maxIterations, 10);
+        });
+        (0, node_test_1.it)('should allow custom patterns', () => {
+            const fixer = new fixer_js_1.AutoFixer();
+            fixer.addPattern({
+                categories: ['custom'],
+                messagePattern: /custom error/,
+                generateFix: () => [{
+                        id: 'custom-fix',
+                        description: 'Custom fix',
+                        file: 'test.ts',
+                        original: '',
+                        fixed: 'fixed',
+                        confidence: 1,
+                        source: 'pattern',
+                    }],
+            });
+            // Pattern should be added (we can't easily test it triggers)
+            node_assert_1.default.ok(true);
+        });
+    });
+    // ==========================================================================
+    // LLM Integration Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('LLM Integration', () => {
+        (0, node_test_1.it)('should accept LLM generator function', () => {
+            const fixer = new fixer_js_1.AutoFixer();
+            const mockGenerator = async (error, context) => {
+                return [{
+                        id: 'llm-fix',
+                        description: 'LLM generated fix',
+                        file: error.file || '',
+                        original: context,
+                        fixed: context.replace('error', 'fixed'),
+                        confidence: 0.8,
+                        source: 'llm',
+                    }];
+            };
+            fixer.setLLMGenerator(mockGenerator);
+            const config = fixer.getConfig();
+            node_assert_1.default.ok(config.llmFixGenerator !== undefined);
+        });
+    });
+    // ==========================================================================
+    // Full Fix Flow Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Fix Flow', () => {
+        (0, node_test_1.it)('should return success for empty errors array', async () => {
+            const fixer = (0, fixer_js_1.getAutoFixer)({ workingDirectory: TEST_DIR });
+            const result = await fixer.fix([]);
+            node_assert_1.default.strictEqual(result.success, true);
+            node_assert_1.default.strictEqual(result.iterations, 0);
+        });
+        (0, node_test_1.it)('should return failure when no candidates generated', async () => {
+            const fixer = (0, fixer_js_1.getAutoFixer)({ workingDirectory: TEST_DIR });
+            const result = await fixer.fix([{
+                    category: 'unknown',
+                    severity: 'error',
+                    message: 'Unknown error type',
+                    raw: 'Unknown',
+                }]);
+            node_assert_1.default.strictEqual(result.success, false);
+            node_assert_1.default.ok(result.error?.includes('No fix candidates'));
+        });
+        (0, node_test_1.it)('should track iterations', async () => {
+            const filePath = path.join(TEST_DIR, 'iter.ts');
+            fs.writeFileSync(filePath, 'const x = 1');
+            const fixer = (0, fixer_js_1.getAutoFixer)({
+                workingDirectory: TEST_DIR,
+                maxIterations: 2,
+                testCommand: 'echo "ok"',
+                buildCommand: 'echo "ok"',
+            });
+            const result = await fixer.fix([{
+                    category: 'syntax',
+                    severity: 'error',
+                    message: 'Missing semicolon',
+                    file: filePath,
+                    line: 1,
+                    raw: 'Missing semicolon',
+                }]);
+            node_assert_1.default.ok(result.iterations >= 1);
+        });
+    });
+    // ==========================================================================
+    // Edge Cases
+    // ==========================================================================
+    (0, node_test_1.describe)('Edge Cases', () => {
+        (0, node_test_1.it)('should handle file read errors gracefully', async () => {
+            const fixer = (0, fixer_js_1.getAutoFixer)({ workingDirectory: TEST_DIR });
+            // Create a directory with the same name as the "file"
+            const dirPath = path.join(TEST_DIR, 'not-a-file');
+            fs.mkdirSync(dirPath);
+            const candidates = await fixer.generateCandidates([{
+                    category: 'syntax',
+                    severity: 'error',
+                    message: 'Error',
+                    file: dirPath,
+                    raw: 'Error',
+                }]);
+            // Should not crash, just return empty
+            node_assert_1.default.strictEqual(candidates.length, 0);
+        });
+        (0, node_test_1.it)('should handle multiple errors in same file', async () => {
+            const filePath = path.join(TEST_DIR, 'multi.ts');
+            fs.writeFileSync(filePath, 'const x = 1\nconst y = 2');
+            const errors = [
+                { category: 'syntax', severity: 'error', message: 'Missing semicolon', file: filePath, line: 1, raw: 'Missing semicolon' },
+                { category: 'syntax', severity: 'error', message: 'Missing semicolon', file: filePath, line: 2, raw: 'Missing semicolon' },
+            ];
+            const candidates = await (0, fixer_js_1.generateFixes)(errors[0]);
+            // Should generate candidates (deduplication happens at fix level)
+            node_assert_1.default.ok(candidates.length >= 0);
+        });
+    });
+});

package/dist/test/integration.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Integration Tests for Genesis 5.x Modules
+ * Tests Memory, Consciousness, World Model, and Daemon modules
+ */
+export {};

package/dist/test/integration.test.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * Integration Tests for Genesis 5.x Modules
+ * Tests Memory, Consciousness, World Model, and Daemon modules
+ */
+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"));
+// Memory Module Tests
+(0, node_test_1.describe)('Memory Module', () => {
+    (0, node_test_1.test)('MemorySystem creates and initializes', async () => {
+        const { createMemorySystem, resetMemorySystem } = await import('../src/memory/index.js');
+        resetMemorySystem();
+        const memory = createMemorySystem();
+        node_assert_1.default.ok(memory, 'Memory system should be created');
+        node_assert_1.default.ok(memory.episodic, 'Episodic store should exist');
+        node_assert_1.default.ok(memory.semantic, 'Semantic store should exist');
+        node_assert_1.default.ok(memory.procedural, 'Procedural store should exist');
+        resetMemorySystem();
+    });
+    (0, node_test_1.test)('EpisodicStore can store and retrieve memories', async () => {
+        const { createEpisodicStore } = await import('../src/memory/episodic.js');
+        const store = createEpisodicStore();
+        // Store a memory using the convenience method
+        const memory = store.createEpisode({
+            what: 'Test event happened',
+            details: { value: 42 },
+            importance: 0.8,
+            feeling: { valence: 0.5, arousal: 0.6 },
+            where: { location: 'test-location', context: 'testing' },
+            who: { agents: ['user'], roles: { user: 'tester' } },
+        });
+        node_assert_1.default.ok(memory.id, 'Should return memory with ID');
+        // Retrieve by ID
+        const retrieved = store.get(memory.id);
+        node_assert_1.default.ok(retrieved, 'Should retrieve memory');
+        node_assert_1.default.strictEqual(retrieved?.content.what, 'Test event happened');
+        // Query
+        const results = store.query({ minImportance: 0.5 });
+        node_assert_1.default.ok(results.length > 0, 'Should find memories with query');
+    });
+    (0, node_test_1.test)('SemanticStore can store and retrieve facts', async () => {
+        const { createSemanticStore } = await import('../src/memory/semantic.js');
+        const store = createSemanticStore();
+        // Store a fact using the convenience method
+        const fact = store.createFact({
+            concept: 'Genesis',
+            definition: 'An autopoietic system',
+            properties: { version: '6.0' },
+            category: 'software',
+            confidence: 0.95,
+            sources: ['specification'],
+        });
+        node_assert_1.default.ok(fact.id, 'Should return fact with ID');
+        // Retrieve
+        const retrieved = store.get(fact.id);
+        node_assert_1.default.ok(retrieved, 'Should retrieve fact');
+        node_assert_1.default.strictEqual(retrieved?.content.concept, 'Genesis');
+    });
+    (0, node_test_1.test)('ProceduralStore can store and retrieve procedures', async () => {
+        const { createProceduralStore } = await import('../src/memory/procedural.js');
+        const store = createProceduralStore();
+        // Store a procedure using createSkill
+        const proc = store.createSkill({
+            name: 'test-procedure',
+            description: 'A test procedure',
+            steps: [
+                { action: 'step1' },
+                { action: 'step2' },
+            ],
+        });
+        node_assert_1.default.ok(proc.id, 'Should return procedure with ID');
+        // Retrieve
+        const retrieved = store.getByName('test-procedure');
+        node_assert_1.default.ok(retrieved, 'Should retrieve procedure by name');
+        node_assert_1.default.strictEqual(retrieved?.content.steps.length, 2, 'Should have 2 steps');
+    });
+    (0, node_test_1.test)('Forgetting module exports functions', async () => {
+        const forgettingModule = await import('../src/memory/forgetting.js');
+        // Just verify the module exports what we expect
+        node_assert_1.default.ok(forgettingModule.calculateRetention, 'Should export calculateRetention');
+        node_assert_1.default.ok(forgettingModule.FORGETTING_THRESHOLDS, 'Should export FORGETTING_THRESHOLDS');
+    });
+});
+// Consciousness Module Tests
+(0, node_test_1.describe)('Consciousness Module', () => {
+    (0, node_test_1.test)('ConsciousnessSystem creates and initializes', async () => {
+        const { createConsciousnessSystem, resetConsciousnessSystem } = await import('../src/consciousness/index.js');
+        resetConsciousnessSystem();
+        const consciousness = createConsciousnessSystem();
+        node_assert_1.default.ok(consciousness, 'Consciousness system should be created');
+        // Check components exist
+        const state = consciousness.getState();
+        node_assert_1.default.ok(state, 'Should have state');
+        resetConsciousnessSystem();
+    });
+    (0, node_test_1.test)('PhiCalculator calculates phi values', async () => {
+        const { createPhiCalculator } = await import('../src/consciousness/phi-calculator.js');
+        const calculator = createPhiCalculator();
+        // Create a system state matching the expected interface
+        const state = {
+            components: [
+                { id: 'node1', type: 'agent', active: true, state: { value: 0.8 }, entropy: 0.5, lastUpdate: new Date() },
+                { id: 'node2', type: 'agent', active: true, state: { value: 0.6 }, entropy: 0.4, lastUpdate: new Date() },
+                { id: 'node3', type: 'agent', active: true, state: { value: 0.4 }, entropy: 0.3, lastUpdate: new Date() },
+            ],
+            connections: [
+                { from: 'node1', to: 'node2', strength: 0.5, informationFlow: 1.0, bidirectional: true },
+                { from: 'node2', to: 'node3', strength: 0.3, informationFlow: 0.8, bidirectional: true },
+                { from: 'node3', to: 'node1', strength: 0.4, informationFlow: 0.7, bidirectional: true },
+            ],
+            stateHash: 'test-hash',
+            timestamp: new Date(),
+        };
+        const result = calculator.calculate(state);
+        node_assert_1.default.ok(typeof result.phi === 'number', 'Phi should be a number');
+        node_assert_1.default.ok(result.phi >= 0, 'Phi should be non-negative');
+    });
+    (0, node_test_1.test)('GlobalWorkspace performs selection and broadcast', async () => {
+        const { createGlobalWorkspace } = await import('../src/consciousness/global-workspace.js');
+        const workspace = createGlobalWorkspace();
+        node_assert_1.default.ok(workspace, 'Workspace should be created');
+        // Get state
+        const state = workspace.getState();
+        node_assert_1.default.ok(state, 'Should have state');
+    });
+    (0, node_test_1.test)('PhiMonitor tracks phi', async () => {
+        const { createPhiMonitor } = await import('../src/consciousness/phi-monitor.js');
+        const monitor = createPhiMonitor();
+        node_assert_1.default.ok(monitor, 'Monitor should be created');
+        // Verify it has the methods we need
+        node_assert_1.default.ok(typeof monitor.update === 'function', 'Should have update method');
+        node_assert_1.default.ok(typeof monitor.getCurrentLevel === 'function', 'Should have getCurrentLevel method');
+    });
+    (0, node_test_1.test)('PhiDecisionMaker makes decisions', async () => {
+        const { createPhiDecisionMaker } = await import('../src/consciousness/phi-decisions.js');
+        const decisionMaker = createPhiDecisionMaker();
+        node_assert_1.default.ok(decisionMaker, 'Decision maker should be created');
+    });
+});
+// World Model Module Tests
+(0, node_test_1.describe)('World Model Module', () => {
+    (0, node_test_1.test)('WorldModelSystem creates and initializes', async () => {
+        const { createWorldModelSystem, resetWorldModelSystem } = await import('../src/world-model/index.js');
+        resetWorldModelSystem();
+        const worldModel = createWorldModelSystem();
+        node_assert_1.default.ok(worldModel, 'World model system should be created');
+        node_assert_1.default.ok(worldModel.encoder, 'Encoder should exist');
+        node_assert_1.default.ok(worldModel.decoder, 'Decoder should exist');
+        node_assert_1.default.ok(worldModel.predictor, 'Predictor should exist');
+        node_assert_1.default.ok(worldModel.twinManager, 'Twin manager should exist');
+        resetWorldModelSystem();
+    });
+    (0, node_test_1.test)('LatentEncoder encodes multimodal inputs', async () => {
+        const { createLatentEncoder } = await import('../src/world-model/encoder.js');
+        const encoder = createLatentEncoder();
+        // Encode text
+        const textLatent = encoder.encode({
+            modality: 'text',
+            data: 'Hello world',
+            timestamp: new Date(),
+            metadata: {},
+        });
+        node_assert_1.default.ok(textLatent, 'Should encode text');
+        node_assert_1.default.ok(textLatent.vector, 'Should have vector');
+        node_assert_1.default.strictEqual(textLatent.vector.length, 512, 'Vector should be 512-dim');
+        // Encode state
+        const stateLatent = encoder.encode({
+            modality: 'state',
+            data: { energy: 0.8, phi: 0.6 },
+            timestamp: new Date(),
+            metadata: {},
+        });
+        node_assert_1.default.ok(stateLatent, 'Should encode state');
+        node_assert_1.default.strictEqual(stateLatent.vector.length, 512, 'Vector should be 512-dim');
+    });
+    (0, node_test_1.test)('LatentDecoder decodes latent states', async () => {
+        const { createLatentEncoder } = await import('../src/world-model/encoder.js');
+        const { createLatentDecoder } = await import('../src/world-model/decoder.js');
+        const encoder = createLatentEncoder();
+        const decoder = createLatentDecoder();
+        // Encode then decode
+        const latent = encoder.encode({
+            modality: 'text',
+            data: 'Test content',
+            timestamp: new Date(),
+            metadata: {},
+        });
+        const textDecoding = decoder.decodeToText(latent);
+        node_assert_1.default.ok(textDecoding, 'Should decode to text');
+        node_assert_1.default.ok(textDecoding.confidence >= 0 && textDecoding.confidence <= 1, 'Confidence should be in [0,1]');
+        const featureDecoding = decoder.decodeToFeatures(latent);
+        node_assert_1.default.ok(featureDecoding, 'Should decode to features');
+    });
+    (0, node_test_1.test)('WorldModelPredictor exists and initializes', async () => {
+        const { createWorldModelPredictor } = await import('../src/world-model/predictor.js');
+        const predictor = createWorldModelPredictor();
+        node_assert_1.default.ok(predictor, 'Predictor should be created');
+        node_assert_1.default.ok(typeof predictor.predict === 'function', 'Should have predict method');
+        node_assert_1.default.ok(typeof predictor.simulate === 'function', 'Should have simulate method');
+    });
+    (0, node_test_1.test)('DigitalTwinManager creates twins', async () => {
+        const { createDigitalTwinManager } = await import('../src/world-model/digital-twin.js');
+        const manager = createDigitalTwinManager();
+        node_assert_1.default.ok(manager, 'Manager should be created');
+        const twin = manager.createTwin('test-system', 'Test System');
+        node_assert_1.default.ok(twin, 'Should create digital twin');
+        node_assert_1.default.strictEqual(twin.name, 'Test System', 'Should have correct name');
+        node_assert_1.default.ok(twin.id, 'Should have ID');
+    });
+});
+// Daemon Module Tests
+(0, node_test_1.describe)('Daemon Module', () => {
+    (0, node_test_1.test)('Scheduler creates and manages tasks', async () => {
+        const { createScheduler } = await import('../src/daemon/scheduler.js');
+        const scheduler = createScheduler();
+        node_assert_1.default.ok(scheduler, 'Scheduler should be created');
+        // Add a task with proper schedule format
+        const task = scheduler.schedule({
+            name: 'test-task',
+            schedule: { type: 'interval', intervalMs: 60000 },
+            handler: async (ctx) => ({ success: true, duration: 10 }),
+        });
+        node_assert_1.default.ok(task, 'Should return task');
+        node_assert_1.default.ok(task.id, 'Task should have ID');
+        // Clean up
+        scheduler.cancel(task.id);
+    });
+    (0, node_test_1.test)('MaintenanceService initializes', async () => {
+        const { createMaintenanceService } = await import('../src/daemon/maintenance.js');
+        const maintenance = createMaintenanceService();
+        node_assert_1.default.ok(maintenance, 'Maintenance service should be created');
+    });
+    (0, node_test_1.test)('DreamService initializes', async () => {
+        const { createDreamService } = await import('../src/daemon/dream-mode.js');
+        const dreamService = createDreamService();
+        node_assert_1.default.ok(dreamService, 'Dream service should be created');
+    });
+});
+// Cross-Module Integration Tests
+(0, node_test_1.describe)('Cross-Module Integration', () => {
+    (0, node_test_1.test)('Memory system stores and retrieves', async () => {
+        const { createMemorySystem, resetMemorySystem } = await import('../src/memory/index.js');
+        resetMemorySystem();
+        const memory = createMemorySystem();
+        // Store an episodic memory
+        const episode = memory.episodic.createEpisode({
+            what: 'Integration test event',
+            details: { test: true },
+            importance: 0.9,
+        });
+        node_assert_1.default.ok(episode.id, 'Should store episode');
+        // Retrieve it
+        const retrieved = memory.episodic.get(episode.id);
+        node_assert_1.default.ok(retrieved, 'Should retrieve episode');
+        resetMemorySystem();
+    });
+    (0, node_test_1.test)('World Model encodes and decodes', async () => {
+        const { createWorldModelSystem, resetWorldModelSystem } = await import('../src/world-model/index.js');
+        resetWorldModelSystem();
+        const worldModel = createWorldModelSystem();
+        // Encode a state
+        const latent = worldModel.encode({
+            modality: 'state',
+            data: { consciousnessLevel: 0.8 },
+            timestamp: new Date(),
+            metadata: {},
+        });
+        node_assert_1.default.ok(latent, 'Should encode state');
+        node_assert_1.default.strictEqual(latent.vector.length, 512, 'Should have 512-dim vector');
+        // Decode back
+        const decoded = worldModel.decoder.decodeToText(latent);
+        node_assert_1.default.ok(decoded, 'Should decode');
+        resetWorldModelSystem();
+    });
+    (0, node_test_1.test)('All modules can be imported together', async () => {
+        const memory = await import('../src/memory/index.js');
+        const consciousness = await import('../src/consciousness/index.js');
+        const worldModel = await import('../src/world-model/index.js');
+        const daemon = await import('../src/daemon/index.js');
+        node_assert_1.default.ok(memory.createMemorySystem, 'Memory should export factory');
+        node_assert_1.default.ok(consciousness.createConsciousnessSystem, 'Consciousness should export factory');
+        node_assert_1.default.ok(worldModel.createWorldModelSystem, 'World model should export factory');
+        node_assert_1.default.ok(daemon.createDaemon, 'Daemon should export factory');
+    });
+});
+console.log('Running Genesis Integration Tests...\n');

package/dist/test/tools/bash.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Genesis Secure Bash Executor
+ */
+export {};