genesis-ai-cli 7.4.5

package/dist/test/grounding/verifier.test.js

@@ -0,0 +1,442 @@
+"use strict";
+/**
+ * Tests for Genesis Grounding Verifier
+ */
+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 verifier_js_1 = require("../../src/grounding/verifier.js");
+// Test directory
+const TEST_DIR = '/tmp/genesis-verifier-test-' + Date.now();
+(0, node_test_1.describe)('Verifier', () => {
+    (0, node_test_1.before)(() => {
+        fs.mkdirSync(TEST_DIR, { recursive: true });
+        (0, verifier_js_1.resetVerifier)();
+    });
+    (0, node_test_1.after)(() => {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+        (0, verifier_js_1.resetVerifier)();
+    });
+    (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 });
+        }
+    });
+    // ==========================================================================
+    // Basic Verification Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Basic Verification', () => {
+        (0, node_test_1.it)('should verify valid TypeScript code', async () => {
+            // Create a simple valid TS file
+            fs.writeFileSync(path.join(TEST_DIR, 'valid.ts'), `
+        export function add(a: number, b: number): number {
+          return a + b;
+        }
+      `);
+            // Create minimal package.json
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                type: 'module',
+                scripts: {
+                    build: 'echo "build ok"',
+                    test: 'echo "test ok"',
+                },
+            }));
+            // Create tsconfig.json
+            fs.writeFileSync(path.join(TEST_DIR, 'tsconfig.json'), JSON.stringify({
+                compilerOptions: {
+                    target: 'ES2022',
+                    module: 'NodeNext',
+                    strict: true,
+                    noEmit: true,
+                },
+                include: ['*.ts'],
+            }));
+            const result = await (0, verifier_js_1.verifyCode)({
+                workingDirectory: TEST_DIR,
+                buildCommand: 'echo "build ok"',
+                testCommand: 'echo "test ok"',
+                timeout: 30000,
+            });
+            node_assert_1.default.ok(result.compiles);
+            node_assert_1.default.ok(result.typesValid);
+        });
+        (0, node_test_1.it)('should detect type errors', async () => {
+            // Create TS file with type error
+            fs.writeFileSync(path.join(TEST_DIR, 'invalid.ts'), `
+        const x: number = "not a number";
+      `);
+            fs.writeFileSync(path.join(TEST_DIR, 'tsconfig.json'), JSON.stringify({
+                compilerOptions: {
+                    target: 'ES2022',
+                    module: 'NodeNext',
+                    strict: true,
+                    noEmit: true,
+                },
+                include: ['*.ts'],
+            }));
+            const result = await (0, verifier_js_1.verifyCode)({
+                workingDirectory: TEST_DIR,
+                buildCommand: 'echo "skip"',
+                testCommand: 'echo "skip"',
+                timeout: 30000,
+            });
+            node_assert_1.default.strictEqual(result.typesValid, false);
+            node_assert_1.default.ok(result.issues.some(i => i.type === 'type'));
+        });
+        (0, node_test_1.it)('should detect build failures', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'exit 1' },
+            }));
+            const verifier = new verifier_js_1.Verifier({ skipTypeCheck: true });
+            const result = await verifier.verify({
+                workingDirectory: TEST_DIR,
+                buildCommand: 'exit 1',
+                testCommand: 'echo "ok"',
+                timeout: 10000,
+            });
+            node_assert_1.default.strictEqual(result.compiles, false);
+            node_assert_1.default.ok(result.issues.some(i => i.type === 'compile'));
+        });
+        (0, node_test_1.it)('should detect test failures', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: {
+                    build: 'echo "ok"',
+                    test: 'exit 1',
+                },
+            }));
+            const verifier = new verifier_js_1.Verifier({ skipTypeCheck: true });
+            const result = await verifier.verify({
+                workingDirectory: TEST_DIR,
+                buildCommand: 'echo "ok"',
+                testCommand: 'echo "FAIL test.ts" && exit 1',
+                timeout: 10000,
+            });
+            node_assert_1.default.strictEqual(result.testsPass, false);
+        });
+    });
+    // ==========================================================================
+    // Test Output Parsing
+    // ==========================================================================
+    (0, node_test_1.describe)('Test Output Parsing', () => {
+        (0, node_test_1.it)('should parse Node test runner output', async () => {
+            const output = `
+        ✔ test 1 (1ms)
+        ✔ test 2 (2ms)
+        ✖ test 3 (3ms)
+        ℹ tests 3
+        ℹ pass 2
+        ℹ fail 1
+      `;
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: `echo "${output}"` },
+            }));
+            const verifier = new verifier_js_1.Verifier({ skipTypeCheck: true, skipBuild: true });
+            const result = await verifier.verify({
+                workingDirectory: TEST_DIR,
+                testCommand: `printf "${output}"`,
+                timeout: 10000,
+            });
+            node_assert_1.default.strictEqual(result.testsTotal, 3);
+            node_assert_1.default.strictEqual(result.testsPassed, 2);
+            node_assert_1.default.strictEqual(result.testsFailed, 1);
+        });
+        (0, node_test_1.it)('should count checkmarks and crosses', async () => {
+            const verifier = new verifier_js_1.Verifier({ skipTypeCheck: true, skipBuild: true });
+            const result = await verifier.verify({
+                workingDirectory: TEST_DIR,
+                testCommand: 'echo "✔ pass1\n✔ pass2\n✖ fail1"',
+                timeout: 10000,
+            });
+            // Should count at least some passes and fails
+            node_assert_1.default.ok(result.testsPassed >= 2);
+            node_assert_1.default.ok(result.testsFailed >= 1);
+        });
+    });
+    // ==========================================================================
+    // Configuration Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Configuration', () => {
+        (0, node_test_1.it)('should use default configuration', () => {
+            const verifier = new verifier_js_1.Verifier();
+            const config = verifier.getConfig();
+            node_assert_1.default.strictEqual(config.buildCommand, 'npm run build');
+            node_assert_1.default.strictEqual(config.testCommand, 'npm test');
+            node_assert_1.default.strictEqual(config.timeout, 120000);
+        });
+        (0, node_test_1.it)('should accept custom configuration', () => {
+            const verifier = new verifier_js_1.Verifier({
+                buildCommand: 'make build',
+                testCommand: 'make test',
+                timeout: 60000,
+            });
+            const config = verifier.getConfig();
+            node_assert_1.default.strictEqual(config.buildCommand, 'make build');
+            node_assert_1.default.strictEqual(config.testCommand, 'make test');
+            node_assert_1.default.strictEqual(config.timeout, 60000);
+        });
+        (0, node_test_1.it)('should update configuration', () => {
+            const verifier = (0, verifier_js_1.getVerifier)();
+            verifier.updateConfig({ skipLint: false, lintCommand: 'eslint .' });
+            const config = verifier.getConfig();
+            node_assert_1.default.strictEqual(config.skipLint, false);
+            node_assert_1.default.strictEqual(config.lintCommand, 'eslint .');
+        });
+        (0, node_test_1.it)('should skip steps when configured', async () => {
+            const verifier = new verifier_js_1.Verifier({
+                skipBuild: true,
+                skipTypeCheck: true,
+                skipTest: true,
+            });
+            const result = await verifier.verify({
+                workingDirectory: TEST_DIR,
+            });
+            // Should succeed since all steps are skipped
+            node_assert_1.default.ok(result.success);
+        });
+    });
+    // ==========================================================================
+    // Single File Verification
+    // ==========================================================================
+    (0, node_test_1.describe)('Single File Verification', () => {
+        (0, node_test_1.it)('should verify valid file', async () => {
+            const filePath = path.join(TEST_DIR, 'single.ts');
+            fs.writeFileSync(filePath, 'const x: number = 42;');
+            fs.writeFileSync(path.join(TEST_DIR, 'tsconfig.json'), JSON.stringify({
+                compilerOptions: { target: 'ES2022', module: 'NodeNext', strict: true, noEmit: true },
+                include: ['*.ts'],
+            }));
+            const verifier = (0, verifier_js_1.getVerifier)();
+            const result = await verifier.verifyFile(filePath, TEST_DIR);
+            node_assert_1.default.ok(result.valid);
+            node_assert_1.default.strictEqual(result.errors.length, 0);
+        });
+        (0, node_test_1.it)('should detect invalid file', async () => {
+            const filePath = path.join(TEST_DIR, 'invalid.ts');
+            fs.writeFileSync(filePath, 'const x: number = "string";');
+            fs.writeFileSync(path.join(TEST_DIR, 'tsconfig.json'), JSON.stringify({
+                compilerOptions: { target: 'ES2022', module: 'NodeNext', strict: true, noEmit: true },
+                include: ['*.ts'],
+            }));
+            const verifier = (0, verifier_js_1.getVerifier)();
+            const result = await verifier.verifyFile(filePath, TEST_DIR);
+            node_assert_1.default.strictEqual(result.valid, false);
+            node_assert_1.default.ok(result.errors.length > 0);
+        });
+        (0, node_test_1.it)('should handle missing file', async () => {
+            const verifier = (0, verifier_js_1.getVerifier)();
+            const result = await verifier.verifyFile('/nonexistent/file.ts', TEST_DIR);
+            node_assert_1.default.strictEqual(result.valid, false);
+            node_assert_1.default.ok(result.errors.some(e => e.message.includes('not found')));
+        });
+    });
+    // ==========================================================================
+    // Semantic Match
+    // ==========================================================================
+    (0, node_test_1.describe)('Semantic Match', () => {
+        (0, node_test_1.it)('should calculate high semantic match for clean code', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: 'echo "ok"' },
+            }));
+            const verifier = new verifier_js_1.Verifier({ skipTypeCheck: true });
+            const result = await verifier.verify({
+                workingDirectory: TEST_DIR,
+                buildCommand: 'echo "ok"',
+                testCommand: 'echo "ok"',
+                modifiedFiles: [],
+                timeout: 10000,
+            });
+            node_assert_1.default.ok(result.semanticMatch >= 0.9);
+        });
+        (0, node_test_1.it)('should reduce semantic match for issues', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'bad.ts'), 'const x: number = "bad";');
+            fs.writeFileSync(path.join(TEST_DIR, 'tsconfig.json'), JSON.stringify({
+                compilerOptions: { target: 'ES2022', module: 'NodeNext', strict: true, noEmit: true },
+                include: ['*.ts'],
+            }));
+            const result = await (0, verifier_js_1.verifyCode)({
+                workingDirectory: TEST_DIR,
+                buildCommand: 'echo "ok"',
+                testCommand: 'echo "ok"',
+                timeout: 30000,
+            });
+            node_assert_1.default.ok(result.semanticMatch < 1.0);
+        });
+    });
+    // ==========================================================================
+    // Formatting
+    // ==========================================================================
+    (0, node_test_1.describe)('Formatting', () => {
+        (0, node_test_1.it)('should format success result', () => {
+            const result = {
+                success: true,
+                compiles: true,
+                typesValid: true,
+                testsPass: true,
+                testsPassed: 10,
+                testsFailed: 0,
+                testsTotal: 10,
+                lintPass: true,
+                semanticMatch: 0.95,
+                issues: [],
+                duration: 1234,
+                outputs: {},
+            };
+            const formatted = (0, verifier_js_1.formatVerificationResult)(result);
+            node_assert_1.default.ok(formatted.includes('PASSED'));
+            node_assert_1.default.ok(formatted.includes('✓'));
+            node_assert_1.default.ok(formatted.includes('10/10'));
+        });
+        (0, node_test_1.it)('should format failure result with issues', () => {
+            const result = {
+                success: false,
+                compiles: false,
+                typesValid: false,
+                testsPass: false,
+                testsPassed: 3,
+                testsFailed: 2,
+                testsTotal: 5,
+                lintPass: true,
+                semanticMatch: 0.5,
+                issues: [
+                    { type: 'type', severity: 'error', message: 'Type mismatch', file: 'test.ts', line: 10 },
+                    { type: 'test', severity: 'error', message: 'Test failed' },
+                ],
+                duration: 2000,
+                outputs: {},
+            };
+            const formatted = (0, verifier_js_1.formatVerificationResult)(result);
+            node_assert_1.default.ok(formatted.includes('FAILED'));
+            node_assert_1.default.ok(formatted.includes('✗'));
+            node_assert_1.default.ok(formatted.includes('Type mismatch'));
+            node_assert_1.default.ok(formatted.includes('Test failed'));
+        });
+    });
+    // ==========================================================================
+    // Convenience Functions
+    // ==========================================================================
+    (0, node_test_1.describe)('Convenience Functions', () => {
+        (0, node_test_1.it)('isCodeValid should return boolean', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: 'echo "ok"' },
+            }));
+            // Skip type check for this simple test
+            (0, verifier_js_1.resetVerifier)();
+            const verifier = (0, verifier_js_1.getVerifier)({ skipTypeCheck: true });
+            const valid = await (0, verifier_js_1.isCodeValid)(TEST_DIR);
+            node_assert_1.default.strictEqual(typeof valid, 'boolean');
+        });
+        (0, node_test_1.it)('quickVerify should skip heavy operations', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'sleep 10', test: 'sleep 10' },
+            }));
+            const startTime = Date.now();
+            const result = await (0, verifier_js_1.quickVerify)({
+                workingDirectory: TEST_DIR,
+                timeout: 5000,
+            });
+            const duration = Date.now() - startTime;
+            // Should be fast because we skip build and test
+            node_assert_1.default.ok(duration < 10000);
+        });
+    });
+    // ==========================================================================
+    // Edge Cases
+    // ==========================================================================
+    (0, node_test_1.describe)('Edge Cases', () => {
+        (0, node_test_1.it)('should handle empty directory', async () => {
+            const verifier = new verifier_js_1.Verifier({ skipTypeCheck: true });
+            const result = await verifier.verify({
+                workingDirectory: TEST_DIR,
+                buildCommand: 'echo "ok"',
+                testCommand: 'echo "ok"',
+                timeout: 10000,
+            });
+            // Should succeed with skipped type check
+            node_assert_1.default.ok(result.success);
+        });
+        (0, node_test_1.it)('should handle command timeout', async () => {
+            const verifier = new verifier_js_1.Verifier({ skipTypeCheck: true });
+            try {
+                await verifier.verify({
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'sleep 30',
+                    timeout: 100, // Very short timeout
+                });
+                // Should have thrown or failed
+            }
+            catch {
+                // Expected to fail
+                node_assert_1.default.ok(true);
+            }
+        });
+        (0, node_test_1.it)('should handle concurrent verifications', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: 'echo "ok"' },
+            }));
+            const verifier = new verifier_js_1.Verifier({ skipTypeCheck: true });
+            const results = await Promise.all([
+                verifier.verify({
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'echo "1"',
+                    testCommand: 'echo "1"',
+                    timeout: 10000,
+                }),
+                verifier.verify({
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'echo "2"',
+                    testCommand: 'echo "2"',
+                    timeout: 10000,
+                }),
+            ]);
+            node_assert_1.default.strictEqual(results.length, 2);
+        });
+    });
+});

package/dist/test/grounding.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests for Grounding Module
+ *
+ * Tests the epistemic stack: science, proof, wisdom, tradition, human, prudence
+ */
+export {};