genesis-ai-cli 7.4.5

package/dist/test/grounding/feedback.test.js

@@ -0,0 +1,462 @@
+"use strict";
+/**
+ * Tests for Genesis Grounding Feedback Loop
+ */
+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 feedback_js_1 = require("../../src/grounding/feedback.js");
+const verifier_js_1 = require("../../src/grounding/verifier.js");
+const fixer_js_1 = require("../../src/healing/fixer.js");
+// Test directory
+const TEST_DIR = '/tmp/genesis-feedback-test-' + Date.now();
+(0, node_test_1.describe)('FeedbackLoop', () => {
+    (0, node_test_1.before)(() => {
+        fs.mkdirSync(TEST_DIR, { recursive: true });
+        (0, feedback_js_1.resetFeedbackLoop)();
+        (0, verifier_js_1.resetVerifier)();
+        (0, fixer_js_1.resetAutoFixer)();
+    });
+    (0, node_test_1.after)(() => {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+        (0, feedback_js_1.resetFeedbackLoop)();
+        (0, verifier_js_1.resetVerifier)();
+        (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 });
+        }
+        (0, feedback_js_1.resetFeedbackLoop)();
+    });
+    // ==========================================================================
+    // Basic Loop Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Basic Loop', () => {
+        (0, node_test_1.it)('should pass on first iteration if code is valid', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: 'echo "ok"' },
+            }));
+            const loop = new feedback_js_1.FeedbackLoop({
+                maxIterations: 3,
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'echo "ok"',
+                    testCommand: 'echo "ok"',
+                    typeCheckCommand: 'echo "ok"',
+                },
+                enableAutoFix: false,
+            });
+            const result = await loop.run();
+            node_assert_1.default.ok(result.success);
+            node_assert_1.default.strictEqual(result.iterations, 1);
+            node_assert_1.default.ok(result.history[0].success);
+        });
+        (0, node_test_1.it)('should track iteration count', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'exit 1' },
+            }));
+            const loop = new feedback_js_1.FeedbackLoop({
+                maxIterations: 3,
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'exit 1',
+                    testCommand: 'echo "ok"',
+                    typeCheckCommand: 'echo "ok"',
+                },
+                enableAutoFix: false,
+            });
+            const result = await loop.run();
+            node_assert_1.default.strictEqual(result.success, false);
+            node_assert_1.default.strictEqual(result.iterations, 3);
+        });
+        (0, node_test_1.it)('should stop on first success when configured', async () => {
+            let callCount = 0;
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: 'echo "ok"' },
+            }));
+            const loop = new feedback_js_1.FeedbackLoop({
+                maxIterations: 5,
+                stopOnSuccess: true,
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'echo "ok"',
+                    testCommand: 'echo "ok"',
+                    typeCheckCommand: 'echo "ok"',
+                },
+                enableAutoFix: false,
+            });
+            const result = await loop.run();
+            node_assert_1.default.ok(result.success);
+            node_assert_1.default.strictEqual(result.iterations, 1);
+        });
+    });
+    // ==========================================================================
+    // Configuration Tests
+    // ==========================================================================
+    (0, node_test_1.describe)('Configuration', () => {
+        (0, node_test_1.it)('should use default configuration', () => {
+            const loop = new feedback_js_1.FeedbackLoop();
+            const config = loop.getConfig();
+            node_assert_1.default.strictEqual(config.maxIterations, 3);
+            node_assert_1.default.strictEqual(config.stopOnSuccess, true);
+            node_assert_1.default.strictEqual(config.enableAutoFix, true);
+        });
+        (0, node_test_1.it)('should accept custom configuration', () => {
+            const loop = new feedback_js_1.FeedbackLoop({
+                maxIterations: 5,
+                stopOnSuccess: false,
+                enableAutoFix: false,
+                verbose: true,
+            });
+            const config = loop.getConfig();
+            node_assert_1.default.strictEqual(config.maxIterations, 5);
+            node_assert_1.default.strictEqual(config.stopOnSuccess, false);
+            node_assert_1.default.strictEqual(config.enableAutoFix, false);
+            node_assert_1.default.strictEqual(config.verbose, true);
+        });
+        (0, node_test_1.it)('should update configuration', () => {
+            const loop = (0, feedback_js_1.getFeedbackLoop)();
+            loop.updateConfig({
+                maxIterations: 10,
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                },
+            });
+            const config = loop.getConfig();
+            node_assert_1.default.strictEqual(config.maxIterations, 10);
+        });
+    });
+    // ==========================================================================
+    // Verification Only
+    // ==========================================================================
+    (0, node_test_1.describe)('Verification Only', () => {
+        (0, node_test_1.it)('should run verification without feedback loop', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: 'echo "ok"' },
+            }));
+            const loop = new feedback_js_1.FeedbackLoop({
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'echo "ok"',
+                    testCommand: 'echo "ok"',
+                    typeCheckCommand: 'echo "ok"',
+                },
+            });
+            const result = await loop.verifyOnly();
+            node_assert_1.default.ok(result.compiles);
+            node_assert_1.default.ok(result.typesValid);
+            node_assert_1.default.ok(result.testsPass);
+        });
+    });
+    // ==========================================================================
+    // History Tracking
+    // ==========================================================================
+    (0, node_test_1.describe)('History Tracking', () => {
+        (0, node_test_1.it)('should record all iterations', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'exit 1' },
+            }));
+            const loop = new feedback_js_1.FeedbackLoop({
+                maxIterations: 3,
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'exit 1',
+                    testCommand: 'echo "ok"',
+                    typeCheckCommand: 'echo "ok"',
+                },
+                enableAutoFix: false,
+            });
+            const result = await loop.run();
+            node_assert_1.default.strictEqual(result.history.length, 3);
+            for (let i = 0; i < result.history.length; i++) {
+                node_assert_1.default.strictEqual(result.history[i].iteration, i + 1);
+                node_assert_1.default.ok(result.history[i].duration >= 0);
+                node_assert_1.default.ok(result.history[i].verification);
+            }
+        });
+        (0, node_test_1.it)('should include fix results when auto-fix is enabled', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'exit 1' },
+            }));
+            const loop = new feedback_js_1.FeedbackLoop({
+                maxIterations: 2,
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'exit 1',
+                    testCommand: 'echo "ok"',
+                    typeCheckCommand: 'echo "ok"',
+                },
+                enableAutoFix: true,
+            });
+            const result = await loop.run();
+            // At least one iteration should have attempted a fix
+            node_assert_1.default.ok(result.history.some(h => h.fix !== undefined));
+        });
+    });
+    // ==========================================================================
+    // Convenience Functions
+    // ==========================================================================
+    (0, node_test_1.describe)('Convenience Functions', () => {
+        (0, node_test_1.it)('runFeedbackLoop should work', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: 'echo "ok"' },
+            }));
+            // Use FeedbackLoop directly since runFeedbackLoop doesn't accept verificationContext
+            const loop = new feedback_js_1.FeedbackLoop({
+                maxIterations: 1,
+                enableAutoFix: false,
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'echo "ok"',
+                    testCommand: 'echo "ok"',
+                    typeCheckCommand: 'echo "ok"',
+                },
+            });
+            const result = await loop.run();
+            node_assert_1.default.ok(result.success);
+        });
+        (0, node_test_1.it)('verifyAndFix should work', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: 'echo "ok"' },
+            }));
+            // Reset and configure
+            (0, feedback_js_1.resetFeedbackLoop)();
+            const loop = (0, feedback_js_1.getFeedbackLoop)({
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'echo "ok"',
+                    testCommand: 'echo "ok"',
+                    typeCheckCommand: 'echo "ok"',
+                },
+            });
+            const result = await (0, feedback_js_1.verifyAndFix)(TEST_DIR, 1);
+            node_assert_1.default.ok(typeof result.success === 'boolean');
+        });
+        (0, node_test_1.it)('isProjectValid should return boolean', async () => {
+            fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify({
+                name: 'test',
+                scripts: { build: 'echo "ok"', test: 'echo "ok"' },
+            }));
+            (0, feedback_js_1.resetFeedbackLoop)();
+            const valid = await (0, feedback_js_1.isProjectValid)(TEST_DIR);
+            node_assert_1.default.strictEqual(typeof valid, 'boolean');
+        });
+    });
+    // ==========================================================================
+    // Formatting
+    // ==========================================================================
+    (0, node_test_1.describe)('Formatting', () => {
+        (0, node_test_1.it)('should format success result', () => {
+            const result = {
+                success: true,
+                iterations: 1,
+                history: [{
+                        iteration: 1,
+                        verification: {
+                            success: true,
+                            compiles: true,
+                            typesValid: true,
+                            testsPass: true,
+                            testsPassed: 10,
+                            testsFailed: 0,
+                            testsTotal: 10,
+                            lintPass: true,
+                            semanticMatch: 0.95,
+                            issues: [],
+                            duration: 1000,
+                            outputs: {},
+                        },
+                        duration: 1000,
+                        success: true,
+                    }],
+                finalResult: {
+                    success: true,
+                    compiles: true,
+                    typesValid: true,
+                    testsPass: true,
+                    testsPassed: 10,
+                    testsFailed: 0,
+                    testsTotal: 10,
+                    lintPass: true,
+                    semanticMatch: 0.95,
+                    issues: [],
+                    duration: 1000,
+                    outputs: {},
+                },
+                totalDuration: 1000,
+                summary: 'Verification passed on first attempt (1000ms)',
+            };
+            const formatted = (0, feedback_js_1.formatFeedbackResult)(result);
+            node_assert_1.default.ok(formatted.includes('SUCCESS'));
+            node_assert_1.default.ok(formatted.includes('first attempt'));
+        });
+        (0, node_test_1.it)('should format failure result with history', () => {
+            const result = {
+                success: false,
+                iterations: 3,
+                history: [
+                    {
+                        iteration: 1,
+                        verification: {
+                            success: false,
+                            compiles: false,
+                            typesValid: true,
+                            testsPass: true,
+                            testsPassed: 0,
+                            testsFailed: 0,
+                            testsTotal: 0,
+                            lintPass: true,
+                            semanticMatch: 0.5,
+                            issues: [{ type: 'compile', severity: 'error', message: 'Build failed' }],
+                            duration: 500,
+                            outputs: {},
+                        },
+                        fix: { success: false, iterations: 1, candidates: [], evaluations: [] },
+                        duration: 600,
+                        success: false,
+                    },
+                    {
+                        iteration: 2,
+                        verification: {
+                            success: false,
+                            compiles: false,
+                            typesValid: true,
+                            testsPass: true,
+                            testsPassed: 0,
+                            testsFailed: 0,
+                            testsTotal: 0,
+                            lintPass: true,
+                            semanticMatch: 0.5,
+                            issues: [{ type: 'compile', severity: 'error', message: 'Build failed' }],
+                            duration: 500,
+                            outputs: {},
+                        },
+                        duration: 500,
+                        success: false,
+                    },
+                    {
+                        iteration: 3,
+                        verification: {
+                            success: false,
+                            compiles: false,
+                            typesValid: true,
+                            testsPass: true,
+                            testsPassed: 0,
+                            testsFailed: 0,
+                            testsTotal: 0,
+                            lintPass: true,
+                            semanticMatch: 0.5,
+                            issues: [{ type: 'compile', severity: 'error', message: 'Build failed' }],
+                            duration: 500,
+                            outputs: {},
+                        },
+                        duration: 500,
+                        success: false,
+                    },
+                ],
+                finalResult: {
+                    success: false,
+                    compiles: false,
+                    typesValid: true,
+                    testsPass: true,
+                    testsPassed: 0,
+                    testsFailed: 0,
+                    testsTotal: 0,
+                    lintPass: true,
+                    semanticMatch: 0.5,
+                    issues: [{ type: 'compile', severity: 'error', message: 'Build failed' }],
+                    duration: 500,
+                    outputs: {},
+                },
+                totalDuration: 1600,
+                summary: 'Verification failed after 3 iterations. 1 issues remaining, 0 fixes attempted (1600ms)',
+            };
+            const formatted = (0, feedback_js_1.formatFeedbackResult)(result);
+            node_assert_1.default.ok(formatted.includes('FAILED'));
+            node_assert_1.default.ok(formatted.includes('3 iterations'));
+            node_assert_1.default.ok(formatted.includes('Iteration History'));
+            node_assert_1.default.ok(formatted.includes('Remaining Issues'));
+        });
+    });
+    // ==========================================================================
+    // Edge Cases
+    // ==========================================================================
+    (0, node_test_1.describe)('Edge Cases', () => {
+        (0, node_test_1.it)('should handle zero max iterations', async () => {
+            const loop = new feedback_js_1.FeedbackLoop({
+                maxIterations: 0,
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                },
+                enableAutoFix: false,
+            });
+            const result = await loop.run();
+            node_assert_1.default.strictEqual(result.iterations, 0);
+            node_assert_1.default.ok(result.finalResult); // Should still have a final result
+        });
+        (0, node_test_1.it)('should handle empty working directory', async () => {
+            const loop = new feedback_js_1.FeedbackLoop({
+                maxIterations: 1,
+                verificationContext: {
+                    workingDirectory: TEST_DIR,
+                    buildCommand: 'echo "ok"',
+                    testCommand: 'echo "ok"',
+                    typeCheckCommand: 'echo "ok"',
+                },
+                enableAutoFix: false,
+            });
+            const result = await loop.run();
+            // Should complete without crashing
+            node_assert_1.default.ok(result.finalResult);
+        });
+    });
+});

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

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