genesis-ai-cli 7.4.5

package/dist/test/grounding.test.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Tests for Grounding Module
+ *
+ * Tests the epistemic stack: science, proof, wisdom, tradition, human, prudence
+ */
+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)('Grounding Module', () => {
+    (0, node_test_1.describe)('Domain Classification', () => {
+        (0, node_test_1.test)('classifies factual questions', async () => {
+            const { classifyDomain } = await import('../src/grounding/index.js');
+            node_assert_1.default.strictEqual(classifyDomain('What is TypeScript?'), 'factual');
+            node_assert_1.default.strictEqual(classifyDomain('How does React work?'), 'factual');
+            node_assert_1.default.strictEqual(classifyDomain('Is it true that water boils at 100C?'), 'factual');
+        });
+        (0, node_test_1.test)('classifies mathematical questions', async () => {
+            const { classifyDomain } = await import('../src/grounding/index.js');
+            node_assert_1.default.strictEqual(classifyDomain('Prove that sqrt(2) is irrational'), 'mathematical');
+            node_assert_1.default.strictEqual(classifyDomain('Calculate the derivative of x^2'), 'mathematical');
+            node_assert_1.default.strictEqual(classifyDomain('Is it provable in ZFC?'), 'mathematical');
+        });
+        (0, node_test_1.test)('classifies ethical questions', async () => {
+            const { classifyDomain } = await import('../src/grounding/index.js');
+            // "should I" pattern
+            node_assert_1.default.strictEqual(classifyDomain('should I release this code'), 'ethical');
+            node_assert_1.default.strictEqual(classifyDomain('is it right to do this'), 'ethical');
+            node_assert_1.default.strictEqual(classifyDomain('what is my moral duty'), 'ethical');
+        });
+        (0, node_test_1.test)('classifies existential questions', async () => {
+            const { classifyDomain } = await import('../src/grounding/index.js');
+            // "meaning" pattern
+            node_assert_1.default.strictEqual(classifyDomain('what is the meaning of life'), 'existential');
+            node_assert_1.default.strictEqual(classifyDomain('what is my purpose'), 'existential');
+            node_assert_1.default.strictEqual(classifyDomain('does it matter in the end'), 'existential');
+        });
+        (0, node_test_1.test)('classifies aesthetic questions', async () => {
+            const { classifyDomain } = await import('../src/grounding/index.js');
+            node_assert_1.default.strictEqual(classifyDomain('Is it beautiful?'), 'aesthetic');
+            node_assert_1.default.strictEqual(classifyDomain('Which do you prefer?'), 'aesthetic');
+        });
+        (0, node_test_1.test)('defaults to factual for unknown patterns', async () => {
+            const { classifyDomain } = await import('../src/grounding/index.js');
+            node_assert_1.default.strictEqual(classifyDomain('some random text'), 'factual');
+        });
+    });
+    (0, node_test_1.describe)('Authority Mapping', () => {
+        (0, node_test_1.test)('maps domains to authorities', async () => {
+            const { getAuthority } = await import('../src/grounding/index.js');
+            node_assert_1.default.deepStrictEqual(getAuthority('factual'), ['science']);
+            node_assert_1.default.deepStrictEqual(getAuthority('mathematical'), ['proof']);
+            node_assert_1.default.deepStrictEqual(getAuthority('ethical'), ['wisdom', 'human']);
+            node_assert_1.default.deepStrictEqual(getAuthority('existential'), ['religion', 'human']);
+            node_assert_1.default.deepStrictEqual(getAuthority('aesthetic'), ['human']);
+            node_assert_1.default.deepStrictEqual(getAuthority('novel'), ['prudence', 'human']);
+        });
+    });
+    (0, node_test_1.describe)('Epistemic Stack', () => {
+        (0, node_test_1.test)('creates and initializes', async () => {
+            const { createEpistemicStack } = await import('../src/grounding/index.js');
+            const stack = createEpistemicStack();
+            node_assert_1.default.ok(stack, 'Stack should be created');
+        });
+        (0, node_test_1.test)('grounds factual claims (without science connected)', async () => {
+            const { createEpistemicStack } = await import('../src/grounding/index.js');
+            const stack = createEpistemicStack();
+            const claim = await stack.ground('What is TypeScript?');
+            node_assert_1.default.strictEqual(claim.domain, 'factual');
+            node_assert_1.default.strictEqual(claim.authority, 'science');
+            // Without science connected, level is unknown
+            node_assert_1.default.strictEqual(claim.level, 'unknown');
+        });
+        (0, node_test_1.test)('grounds ethical claims with wisdom', async () => {
+            const { createEpistemicStack } = await import('../src/grounding/index.js');
+            const stack = createEpistemicStack();
+            const claim = await stack.ground('should I do this');
+            node_assert_1.default.strictEqual(claim.domain, 'ethical');
+            node_assert_1.default.strictEqual(claim.authority, 'wisdom');
+            // Human is last in authority chain, so level ends at preference
+            node_assert_1.default.strictEqual(claim.level, 'preference');
+            node_assert_1.default.ok(claim.grounding.humanConsultation?.required, 'Should require human');
+        });
+        (0, node_test_1.test)('grounds existential claims with tradition', async () => {
+            const { createEpistemicStack } = await import('../src/grounding/index.js');
+            const stack = createEpistemicStack();
+            const claim = await stack.ground('what is the meaning of life');
+            node_assert_1.default.strictEqual(claim.domain, 'existential');
+            node_assert_1.default.strictEqual(claim.authority, 'religion');
+            // Human is last in authority chain, so level ends at preference
+            node_assert_1.default.strictEqual(claim.level, 'preference');
+            node_assert_1.default.ok(claim.grounding.humanConsultation?.required, 'Should require human');
+        });
+        (0, node_test_1.test)('generates human questions', async () => {
+            const { createEpistemicStack } = await import('../src/grounding/index.js');
+            const stack = createEpistemicStack();
+            const claim = await stack.ground('Should I release this?');
+            const question = stack.getHumanQuestion(claim);
+            node_assert_1.default.ok(question, 'Should generate question');
+            node_assert_1.default.ok(question.includes('release this'), 'Question should include claim');
+        });
+        (0, node_test_1.test)('incorporates human response', async () => {
+            const { createEpistemicStack } = await import('../src/grounding/index.js');
+            const stack = createEpistemicStack();
+            let claim = await stack.ground('Should I proceed?');
+            node_assert_1.default.ok(stack.requiresHuman(claim), 'Should require human');
+            claim = stack.incorporateHumanResponse(claim, 'Yes, proceed');
+            node_assert_1.default.strictEqual(claim.grounding.humanConsultation?.response, 'Yes, proceed');
+            node_assert_1.default.strictEqual(claim.level, 'preference');
+            node_assert_1.default.ok(claim.confidence > 0.8, 'Confidence should be high after human');
+        });
+    });
+    (0, node_test_1.describe)('Wisdom Repository', () => {
+        (0, node_test_1.test)('contains wisdom sources', async () => {
+            const { WISDOM_REPOSITORY } = await import('../src/grounding/index.js');
+            node_assert_1.default.ok(WISDOM_REPOSITORY.length > 0, 'Should have wisdom');
+            // Check structure
+            const wisdom = WISDOM_REPOSITORY[0];
+            node_assert_1.default.ok(wisdom.type, 'Should have type');
+            node_assert_1.default.ok(wisdom.content, 'Should have content');
+            node_assert_1.default.ok(wisdom.origin, 'Should have origin');
+            node_assert_1.default.ok(typeof wisdom.applicability === 'number', 'Should have applicability');
+        });
+        (0, node_test_1.test)('contains prudential heuristics', async () => {
+            const { WISDOM_REPOSITORY } = await import('../src/grounding/index.js');
+            const prudential = WISDOM_REPOSITORY.filter(w => w.content.includes('reversible') || w.content.includes('doubt'));
+            node_assert_1.default.ok(prudential.length > 0, 'Should have prudential wisdom');
+        });
+    });
+    (0, node_test_1.describe)('Tradition Repository', () => {
+        (0, node_test_1.test)('contains tradition sources', async () => {
+            const { TRADITION_REPOSITORY } = await import('../src/grounding/index.js');
+            node_assert_1.default.ok(TRADITION_REPOSITORY.length > 0, 'Should have traditions');
+            // Check structure
+            const tradition = TRADITION_REPOSITORY[0];
+            node_assert_1.default.ok(tradition.type, 'Should have type');
+            node_assert_1.default.ok(tradition.tradition, 'Should have tradition name');
+            node_assert_1.default.ok(tradition.content, 'Should have content');
+            node_assert_1.default.ok(typeof tradition.universality === 'number', 'Should have universality');
+        });
+        (0, node_test_1.test)('contains universal moral absolutes', async () => {
+            const { TRADITION_REPOSITORY } = await import('../src/grounding/index.js');
+            const absolutes = TRADITION_REPOSITORY.filter(t => t.type === 'moral_absolute' && t.universality > 0.9);
+            node_assert_1.default.ok(absolutes.length > 0, 'Should have moral absolutes');
+        });
+        (0, node_test_1.test)('contains meaning frameworks', async () => {
+            const { TRADITION_REPOSITORY } = await import('../src/grounding/index.js');
+            const frameworks = TRADITION_REPOSITORY.filter(t => t.type === 'meaning_framework');
+            node_assert_1.default.ok(frameworks.length >= 3, 'Should have multiple meaning frameworks');
+        });
+    });
+    (0, node_test_1.describe)('Grounding System', () => {
+        (0, node_test_1.test)('creates and initializes', async () => {
+            const { createGroundingSystem, resetGroundingSystem } = await import('../src/grounding/index.js');
+            resetGroundingSystem();
+            const system = createGroundingSystem();
+            node_assert_1.default.ok(system, 'System should be created');
+        });
+        (0, node_test_1.test)('grounds claims', async () => {
+            const { createGroundingSystem } = await import('../src/grounding/index.js');
+            const system = createGroundingSystem();
+            const claim = await system.ground('What is React?');
+            node_assert_1.default.ok(claim, 'Should return claim');
+            node_assert_1.default.ok(claim.domain, 'Should have domain');
+            node_assert_1.default.ok(claim.authority, 'Should have authority');
+            node_assert_1.default.ok(claim.level, 'Should have level');
+        });
+        (0, node_test_1.test)('tracks statistics', async () => {
+            const { createGroundingSystem } = await import('../src/grounding/index.js');
+            const system = createGroundingSystem();
+            await system.ground('What is TypeScript?');
+            await system.ground('should I do this');
+            await system.ground('what is the meaning of life');
+            const stats = system.stats();
+            node_assert_1.default.strictEqual(stats.claimsGrounded, 3);
+            node_assert_1.default.ok(stats.humanConsultations >= 2, 'Should have human consultations');
+            // Check that we tracked some domains (may escalate to human on low confidence)
+            node_assert_1.default.ok(stats.byDomain.factual >= 1, 'Should track factual');
+            node_assert_1.default.ok(stats.byDomain.ethical >= 1, 'Should track ethical');
+            node_assert_1.default.ok(stats.byDomain.existential >= 1, 'Should track existential');
+        });
+        (0, node_test_1.test)('escalates to human on low confidence', async () => {
+            const { createGroundingSystem } = await import('../src/grounding/index.js');
+            const system = createGroundingSystem({
+                uncertaintyThreshold: 0.9, // Very high threshold
+                defaultToHumanOnUncertainty: true,
+            });
+            const claim = await system.ground('Something uncertain');
+            node_assert_1.default.ok(system.needsHuman(claim), 'Should escalate to human');
+        });
+        (0, node_test_1.test)('provides wisdom and tradition access', async () => {
+            const { createGroundingSystem } = await import('../src/grounding/index.js');
+            const system = createGroundingSystem();
+            const wisdom = system.getWisdom();
+            const traditions = system.getTraditions();
+            node_assert_1.default.ok(wisdom.length > 0, 'Should have wisdom');
+            node_assert_1.default.ok(traditions.length > 0, 'Should have traditions');
+        });
+        (0, node_test_1.test)('allows adding custom wisdom', async () => {
+            const { createGroundingSystem } = await import('../src/grounding/index.js');
+            const system = createGroundingSystem();
+            const initialCount = system.getWisdom().length;
+            system.addWisdom({
+                type: 'heuristic',
+                content: 'Test wisdom',
+                origin: 'Test',
+                applicability: 0.5,
+            });
+            node_assert_1.default.strictEqual(system.getWisdom().length, initialCount + 1);
+        });
+    });
+    (0, node_test_1.describe)('Integration with Science', () => {
+        (0, node_test_1.test)('connects science grounding function', async () => {
+            const { createGroundingSystem } = await import('../src/grounding/index.js');
+            const system = createGroundingSystem();
+            // Mock science grounding
+            system.connectScience(async (claim) => ({
+                sources: [
+                    { type: 'paper', reference: 'test-paper', confidence: 0.9 }
+                ],
+                consensusLevel: 'settled',
+            }));
+            const claim = await system.ground('What is TypeScript?');
+            node_assert_1.default.ok(claim.grounding.sources.length > 0, 'Should have sources');
+            node_assert_1.default.ok(claim.confidence > 0.5, 'Should have higher confidence');
+        });
+        (0, node_test_1.test)('connects proof checker', async () => {
+            const { createGroundingSystem } = await import('../src/grounding/index.js');
+            const system = createGroundingSystem();
+            // Mock proof checker
+            system.connectProof(async (claim) => ({
+                sources: [
+                    { type: 'proof', reference: 'formal-proof', confidence: 1.0 }
+                ],
+                consensusLevel: 'settled',
+            }));
+            const claim = await system.ground('Prove that 1+1=2');
+            node_assert_1.default.ok(claim.grounding.sources.length > 0, 'Should have proof sources');
+            node_assert_1.default.strictEqual(claim.level, 'verified', 'Should be verified');
+        });
+    });
+});
+console.log('Running Grounding Module Tests...\n');

package/dist/test/healing/detector.test.d.ts

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

package/dist/test/healing/detector.test.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * Tests for Genesis Error Detector
+ */
+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 detector_js_1 = require("../../src/healing/detector.js");
+(0, node_test_1.describe)('ErrorDetector', () => {
+    (0, node_test_1.before)(() => {
+        (0, detector_js_1.resetErrorDetector)();
+    });
+    (0, node_test_1.after)(() => {
+        (0, detector_js_1.resetErrorDetector)();
+    });
+    // ==========================================================================
+    // TypeScript Error Detection
+    // ==========================================================================
+    (0, node_test_1.describe)('TypeScript Errors', () => {
+        (0, node_test_1.it)('should detect TS errors with file:line:col format', () => {
+            const output = `src/index.ts:10:5 - error TS2322: Type 'string' is not assignable to type 'number'.`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.success, false);
+            node_assert_1.default.strictEqual(result.errors.length, 1);
+            node_assert_1.default.strictEqual(result.errors[0].category, 'type');
+            node_assert_1.default.strictEqual(result.errors[0].file, 'src/index.ts');
+            node_assert_1.default.strictEqual(result.errors[0].line, 10);
+            node_assert_1.default.strictEqual(result.errors[0].code, 'TS2322');
+        });
+        (0, node_test_1.it)('should detect TS errors with (line,col) format', () => {
+            const output = `src/utils.ts(25,10): error TS2339: Property 'foo' does not exist on type 'Bar'.`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length, 1);
+            node_assert_1.default.strictEqual(result.errors[0].file, 'src/utils.ts');
+            node_assert_1.default.strictEqual(result.errors[0].line, 25);
+            node_assert_1.default.strictEqual(result.errors[0].column, 10);
+        });
+        (0, node_test_1.it)('should detect multiple TS errors', () => {
+            const output = `
+src/a.ts:1:1 - error TS1234: First error
+src/b.ts:2:2 - error TS5678: Second error
+src/c.ts:3:3 - error TS9012: Third error
+      `;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length, 3);
+            node_assert_1.default.strictEqual(result.byCategory.type, 3);
+        });
+    });
+    // ==========================================================================
+    // Runtime Error Detection
+    // ==========================================================================
+    (0, node_test_1.describe)('Runtime Errors', () => {
+        (0, node_test_1.it)('should detect TypeError', () => {
+            const output = `TypeError: Cannot read property 'foo' of undefined`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length, 1);
+            node_assert_1.default.strictEqual(result.errors[0].category, 'runtime');
+            node_assert_1.default.strictEqual(result.errors[0].code, 'TypeError');
+        });
+        (0, node_test_1.it)('should detect ReferenceError', () => {
+            const output = `ReferenceError: myVar is not defined`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length, 1);
+            node_assert_1.default.strictEqual(result.errors[0].category, 'runtime');
+        });
+        (0, node_test_1.it)('should detect stack traces', () => {
+            const output = `
+Error: Something went wrong
+    at Object.<anonymous> (/path/to/file.js:10:20)
+    at Module._compile (node:internal/modules/cjs/loader:1234:14)
+      `;
+            const result = (0, detector_js_1.detectErrors)(output);
+            // Should have the error and stack trace entries
+            node_assert_1.default.ok(result.errors.length >= 1);
+        });
+    });
+    // ==========================================================================
+    // Test Failure Detection
+    // ==========================================================================
+    (0, node_test_1.describe)('Test Failures', () => {
+        (0, node_test_1.it)('should detect Node test runner failures', () => {
+            const output = `✖ should do something (5.123ms)`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length, 1);
+            node_assert_1.default.strictEqual(result.errors[0].category, 'test');
+        });
+        (0, node_test_1.it)('should detect assertion errors', () => {
+            const output = `AssertionError [ERR_ASSERTION]: Expected values to be strictly equal`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.ok(result.errors.length >= 1);
+            node_assert_1.default.ok(result.errors.some(e => e.category === 'test'));
+        });
+        (0, node_test_1.it)('should detect Jest FAIL markers', () => {
+            const output = `FAIL src/components/Button.test.tsx`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length, 1);
+            node_assert_1.default.strictEqual(result.errors[0].category, 'test');
+            node_assert_1.default.ok(result.errors[0].file?.includes('Button.test.tsx'));
+        });
+    });
+    // ==========================================================================
+    // Syntax Error Detection
+    // ==========================================================================
+    (0, node_test_1.describe)('Syntax Errors', () => {
+        (0, node_test_1.it)('should detect SyntaxError', () => {
+            const output = `SyntaxError: Unexpected token '}'`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.ok(result.errors.length >= 1);
+            node_assert_1.default.ok(result.errors.some(e => e.category === 'syntax'));
+        });
+        (0, node_test_1.it)('should detect unexpected token errors', () => {
+            const output = `Unexpected token 'const' at line 15`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length, 1);
+            node_assert_1.default.strictEqual(result.errors[0].category, 'syntax');
+        });
+    });
+    // ==========================================================================
+    // Dependency Error Detection
+    // ==========================================================================
+    (0, node_test_1.describe)('Dependency Errors', () => {
+        (0, node_test_1.it)('should detect missing module', () => {
+            const output = `Error: Cannot find module 'lodash'`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length >= 1, true);
+            const depError = result.errors.find(e => e.category === 'dependency');
+            node_assert_1.default.ok(depError);
+            node_assert_1.default.ok(depError.message.includes('lodash'));
+        });
+        (0, node_test_1.it)('should detect npm errors', () => {
+            const output = `ERR! code ERESOLVE
+ERR! Cannot resolve dependency tree`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.ok(result.errors.some(e => e.category === 'dependency'));
+        });
+    });
+    // ==========================================================================
+    // ESLint Error Detection
+    // ==========================================================================
+    (0, node_test_1.describe)('Lint Errors', () => {
+        (0, node_test_1.it)('should detect ESLint errors', () => {
+            const output = `  12:5  error  'foo' is defined but never used  @typescript-eslint/no-unused-vars`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length, 1);
+            node_assert_1.default.strictEqual(result.errors[0].category, 'lint');
+            node_assert_1.default.strictEqual(result.errors[0].line, 12);
+        });
+        (0, node_test_1.it)('should detect ESLint warnings', () => {
+            const output = `  5:10  warning  Unexpected console statement  no-console`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.errors.length, 1);
+            node_assert_1.default.strictEqual(result.errors[0].severity, 'warning');
+        });
+    });
+    // ==========================================================================
+    // Result Aggregation
+    // ==========================================================================
+    (0, node_test_1.describe)('Result Aggregation', () => {
+        (0, node_test_1.it)('should count by category', () => {
+            const output = `
+TypeError: Runtime error
+SyntaxError: Syntax issue
+src/test.ts:1:1 - error TS1234: Type error
+      `;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.ok(result.byCategory.runtime >= 1);
+            node_assert_1.default.ok(result.byCategory.syntax >= 1);
+            node_assert_1.default.ok(result.byCategory.type >= 1);
+        });
+        (0, node_test_1.it)('should count by severity', () => {
+            const output = `
+  1:1  error  Something wrong  rule1
+  2:2  warning  Something sus  rule2
+      `;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.ok(result.bySeverity.error >= 1);
+            node_assert_1.default.ok(result.bySeverity.warning >= 1);
+        });
+        (0, node_test_1.it)('should indicate success when no errors', () => {
+            const output = `Build completed successfully.
+✔ All tests passed (10 tests)`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.success, true);
+            node_assert_1.default.strictEqual(result.bySeverity.error, 0);
+        });
+        (0, node_test_1.it)('should indicate hasFixable for errors with fixHint', () => {
+            const output = `SyntaxError: Missing semicolon`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            node_assert_1.default.strictEqual(result.hasFixable, true);
+        });
+    });
+    // ==========================================================================
+    // Convenience Functions
+    // ==========================================================================
+    (0, node_test_1.describe)('Convenience Functions', () => {
+        (0, node_test_1.it)('hasErrors should return true for errors', () => {
+            node_assert_1.default.strictEqual((0, detector_js_1.hasErrors)('TypeError: Something failed'), true);
+        });
+        (0, node_test_1.it)('hasErrors should return false for clean output', () => {
+            node_assert_1.default.strictEqual((0, detector_js_1.hasErrors)('All good!'), false);
+        });
+        (0, node_test_1.it)('formatErrorReport should format errors nicely', () => {
+            const output = `TypeError: Cannot read property 'x' of null`;
+            const report = (0, detector_js_1.formatErrorReport)(output);
+            node_assert_1.default.ok(report.includes('error'));
+            node_assert_1.default.ok(report.includes('TypeError'));
+        });
+    });
+    // ==========================================================================
+    // Fix Suggestions
+    // ==========================================================================
+    (0, node_test_1.describe)('Fix Suggestions', () => {
+        (0, node_test_1.it)('should suggest fixes for type errors', () => {
+            const detector = (0, detector_js_1.getErrorDetector)();
+            const error = {
+                category: 'type',
+                severity: 'error',
+                message: 'Type mismatch',
+                raw: 'Type mismatch',
+                fixHint: 'type_mismatch',
+            };
+            const suggestions = detector.suggestFix(error);
+            node_assert_1.default.ok(suggestions.length > 0);
+            node_assert_1.default.ok(suggestions.some(s => s.includes('type')));
+        });
+        (0, node_test_1.it)('should suggest npm install for dependency errors', () => {
+            const detector = (0, detector_js_1.getErrorDetector)();
+            const error = {
+                category: 'dependency',
+                severity: 'error',
+                message: 'Missing module: lodash',
+                raw: "Cannot find module 'lodash'",
+                code: 'lodash',
+                fixHint: 'install_dependency',
+            };
+            const suggestions = detector.suggestFix(error);
+            node_assert_1.default.ok(suggestions.some(s => s.includes('npm install lodash')));
+        });
+    });
+    // ==========================================================================
+    // Edge Cases
+    // ==========================================================================
+    (0, node_test_1.describe)('Edge Cases', () => {
+        (0, node_test_1.it)('should handle empty output', () => {
+            const result = (0, detector_js_1.detectErrors)('');
+            node_assert_1.default.strictEqual(result.success, true);
+            node_assert_1.default.strictEqual(result.errors.length, 0);
+        });
+        (0, node_test_1.it)('should handle very long output', () => {
+            const longOutput = 'error '.repeat(10000);
+            const result = (0, detector_js_1.detectErrors)(longOutput);
+            // Should not crash
+            node_assert_1.default.ok(Array.isArray(result.errors));
+        });
+        (0, node_test_1.it)('should deduplicate identical errors', () => {
+            const output = `TypeError: Error
+TypeError: Error`;
+            const result = (0, detector_js_1.detectErrors)(output);
+            // Same error text should be deduplicated
+            node_assert_1.default.ok(result.errors.length <= 2);
+        });
+    });
+});

package/dist/test/healing/fixer.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Genesis Auto-Fix Engine
+ */
+export {};