genesis-ai-cli 7.4.5

package/dist/src/healing/fixer.js

@@ -0,0 +1,572 @@
+"use strict";
+/**
+ * Genesis Auto-Fix Engine (Darwin-Gödel Pattern)
+ *
+ * Automatically fixes detected errors using:
+ * 1. Mutate: Generate N fix candidates via LLM
+ * 2. Test: Run test suite on each
+ * 3. Select: Keep the one that passes most tests
+ * 4. Iterate: If none pass, analyze failures and retry
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoFixer = void 0;
+exports.getAutoFixer = getAutoFixer;
+exports.resetAutoFixer = resetAutoFixer;
+exports.autoFix = autoFix;
+exports.generateFixes = generateFixes;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const detector_js_1 = require("./detector.js");
+const bash_js_1 = require("../tools/bash.js");
+const edit_js_1 = require("../tools/edit.js");
+const FIX_PATTERNS = [
+    // Missing semicolon
+    {
+        categories: ['syntax'],
+        messagePattern: /missing semicolon/i,
+        generateFix: (error, content) => {
+            if (!error.line)
+                return [];
+            const lines = content.split('\n');
+            const lineIdx = error.line - 1;
+            if (lineIdx >= lines.length)
+                return [];
+            const line = lines[lineIdx];
+            if (!line.trim().endsWith(';')) {
+                const fixed = [...lines];
+                fixed[lineIdx] = line.trimEnd() + ';';
+                return [{
+                        id: `fix-semicolon-${error.line}`,
+                        description: `Add missing semicolon at line ${error.line}`,
+                        file: error.file || '',
+                        original: content,
+                        fixed: fixed.join('\n'),
+                        confidence: 0.9,
+                        source: 'pattern',
+                    }];
+            }
+            return [];
+        },
+    },
+    // Undefined variable - add declaration
+    {
+        categories: ['runtime', 'type'],
+        messagePattern: /is not defined|Cannot find name/i,
+        generateFix: (error, content) => {
+            // Extract variable name from error
+            const match = error.message.match(/'(\w+)' is not defined|Cannot find name '(\w+)'/);
+            if (!match)
+                return [];
+            const varName = match[1] || match[2];
+            const lines = content.split('\n');
+            // Add declaration at the top of the file (after imports)
+            let insertIdx = 0;
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].startsWith('import ') || lines[i].startsWith('export ')) {
+                    insertIdx = i + 1;
+                }
+            }
+            const fixed = [...lines];
+            fixed.splice(insertIdx, 0, `let ${varName}: any; // TODO: Add proper type`);
+            return [{
+                    id: `fix-undefined-${varName}`,
+                    description: `Declare undefined variable '${varName}'`,
+                    file: error.file || '',
+                    original: content,
+                    fixed: fixed.join('\n'),
+                    confidence: 0.5,
+                    source: 'heuristic',
+                }];
+        },
+    },
+    // Missing import
+    {
+        categories: ['dependency'],
+        messagePattern: /Cannot find module '(.+)'/,
+        generateFix: (error) => {
+            const match = error.message.match(/Cannot find module '(.+)'/);
+            if (!match)
+                return [];
+            const moduleName = match[1];
+            // This is a special case - we return a "command" fix
+            return [{
+                    id: `fix-import-${moduleName}`,
+                    description: `Install missing module '${moduleName}'`,
+                    file: 'package.json',
+                    original: '',
+                    fixed: `npm install ${moduleName}`,
+                    confidence: 0.8,
+                    source: 'pattern',
+                }];
+        },
+    },
+    // Type assertion fix
+    {
+        categories: ['type'],
+        messagePattern: /Type '(.+)' is not assignable to type '(.+)'/,
+        generateFix: (error, content) => {
+            if (!error.line || !error.column)
+                return [];
+            const match = error.message.match(/Type '(.+)' is not assignable to type '(.+)'/);
+            if (!match)
+                return [];
+            const [, actualType, expectedType] = match;
+            const lines = content.split('\n');
+            const lineIdx = error.line - 1;
+            const line = lines[lineIdx];
+            // Try to find the expression and add type assertion
+            // This is a simplistic approach
+            const candidates = [];
+            // Option 1: Add 'as' assertion
+            const col = error.column - 1;
+            // Find the end of the expression
+            let endCol = col;
+            while (endCol < line.length && /[\w\.\[\]()]/.test(line[endCol])) {
+                endCol++;
+            }
+            if (endCol > col) {
+                const expr = line.slice(col, endCol);
+                const fixedLine = line.slice(0, endCol) + ` as ${expectedType}` + line.slice(endCol);
+                const fixed = [...lines];
+                fixed[lineIdx] = fixedLine;
+                candidates.push({
+                    id: `fix-type-assertion-${error.line}`,
+                    description: `Add type assertion 'as ${expectedType}'`,
+                    file: error.file || '',
+                    original: content,
+                    fixed: fixed.join('\n'),
+                    confidence: 0.6,
+                    source: 'heuristic',
+                });
+            }
+            return candidates;
+        },
+    },
+    // Null check fix
+    {
+        categories: ['type', 'runtime'],
+        messagePattern: /possibly 'null'|possibly 'undefined'|is possibly/i,
+        generateFix: (error, content) => {
+            if (!error.line)
+                return [];
+            const lines = content.split('\n');
+            const lineIdx = error.line - 1;
+            const line = lines[lineIdx];
+            // Find property access that might be null
+            const match = line.match(/(\w+(?:\.\w+)*)\./);
+            if (!match)
+                return [];
+            const expr = match[1];
+            const candidates = [];
+            // Option 1: Optional chaining
+            const fixed1 = line.replace(new RegExp(`${expr}\\.`), `${expr}?.`);
+            if (fixed1 !== line) {
+                const fixedLines1 = [...lines];
+                fixedLines1[lineIdx] = fixed1;
+                candidates.push({
+                    id: `fix-optional-chain-${error.line}`,
+                    description: `Use optional chaining for '${expr}'`,
+                    file: error.file || '',
+                    original: content,
+                    fixed: fixedLines1.join('\n'),
+                    confidence: 0.7,
+                    source: 'heuristic',
+                });
+            }
+            // Option 2: Null check
+            const indent = line.match(/^(\s*)/)?.[1] || '';
+            const fixedLines2 = [...lines];
+            fixedLines2.splice(lineIdx, 0, `${indent}if (${expr}) {`);
+            fixedLines2[lineIdx + 1] = indent + '  ' + line.trim();
+            fixedLines2.splice(lineIdx + 2, 0, `${indent}}`);
+            candidates.push({
+                id: `fix-null-check-${error.line}`,
+                description: `Add null check for '${expr}'`,
+                file: error.file || '',
+                original: content,
+                fixed: fixedLines2.join('\n'),
+                confidence: 0.5,
+                source: 'heuristic',
+            });
+            return candidates;
+        },
+    },
+];
+// ============================================================================
+// Auto-Fixer Class
+// ============================================================================
+class AutoFixer {
+    config;
+    patterns;
+    constructor(config) {
+        this.config = {
+            maxCandidates: 5,
+            maxIterations: 3,
+            testCommand: 'npm test',
+            buildCommand: 'npm run build',
+            workingDirectory: process.cwd(),
+            createBackup: true,
+            ...config,
+        };
+        this.patterns = [...FIX_PATTERNS];
+    }
+    // --------------------------------------------------------------------------
+    // Main Fix Flow
+    // --------------------------------------------------------------------------
+    /**
+     * Attempt to fix errors automatically (Darwin-Gödel pattern)
+     */
+    async fix(errors) {
+        if (errors.length === 0) {
+            return { success: true, candidates: [], evaluations: [], iterations: 0 };
+        }
+        const allCandidates = [];
+        const allEvaluations = [];
+        let iterations = 0;
+        let currentErrors = [...errors];
+        while (iterations < this.config.maxIterations && currentErrors.length > 0) {
+            iterations++;
+            // 1. MUTATE: Generate fix candidates
+            const candidates = await this.generateCandidates(currentErrors);
+            allCandidates.push(...candidates);
+            if (candidates.length === 0) {
+                return {
+                    success: false,
+                    candidates: allCandidates,
+                    evaluations: allEvaluations,
+                    iterations,
+                    error: 'No fix candidates could be generated',
+                };
+            }
+            // 2. TEST: Evaluate each candidate
+            const evaluations = await this.evaluateCandidates(candidates);
+            allEvaluations.push(...evaluations);
+            // 3. SELECT: Find the best candidate
+            const best = this.selectBest(evaluations);
+            if (best && best.testsPass && best.buildSuccess) {
+                // Success! Apply the fix
+                const applied = await this.applyFix(best.candidate);
+                if (applied) {
+                    return {
+                        success: true,
+                        appliedFix: best.candidate,
+                        candidates: allCandidates,
+                        evaluations: allEvaluations,
+                        iterations,
+                    };
+                }
+            }
+            // 4. ITERATE: Analyze failures and retry with new context
+            if (best) {
+                // Update errors based on what was partially fixed
+                currentErrors = best.newErrors;
+            }
+            else {
+                // No progress, break
+                break;
+            }
+        }
+        return {
+            success: false,
+            candidates: allCandidates,
+            evaluations: allEvaluations,
+            iterations,
+            error: `Could not fix all errors after ${iterations} iterations`,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Candidate Generation
+    // --------------------------------------------------------------------------
+    /**
+     * Generate fix candidates for errors
+     */
+    async generateCandidates(errors) {
+        const candidates = [];
+        for (const error of errors) {
+            // Skip errors without file information
+            if (!error.file)
+                continue;
+            const filePath = path.isAbsolute(error.file)
+                ? error.file
+                : path.join(this.config.workingDirectory, error.file);
+            if (!fs.existsSync(filePath))
+                continue;
+            // Skip directories
+            try {
+                if (!fs.statSync(filePath).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const content = fs.readFileSync(filePath, 'utf-8');
+            // Try pattern-based fixes first
+            for (const pattern of this.patterns) {
+                if (!pattern.categories.includes(error.category))
+                    continue;
+                if (pattern.messagePattern && !pattern.messagePattern.test(error.message))
+                    continue;
+                if (pattern.codePattern && error.code && !pattern.codePattern.test(error.code))
+                    continue;
+                const patternCandidates = pattern.generateFix(error, content);
+                candidates.push(...patternCandidates);
+            }
+            // Try LLM-based fixes if available
+            if (this.config.llmFixGenerator) {
+                try {
+                    const llmCandidates = await this.config.llmFixGenerator(error, content);
+                    candidates.push(...llmCandidates);
+                }
+                catch {
+                    // LLM generation failed, continue with pattern-based fixes
+                }
+            }
+        }
+        // Deduplicate and limit
+        const seen = new Set();
+        return candidates
+            .filter(c => {
+            if (seen.has(c.id))
+                return false;
+            seen.add(c.id);
+            return true;
+        })
+            .slice(0, this.config.maxCandidates * errors.length);
+    }
+    // --------------------------------------------------------------------------
+    // Candidate Evaluation
+    // --------------------------------------------------------------------------
+    /**
+     * Evaluate fix candidates
+     */
+    async evaluateCandidates(candidates) {
+        const results = [];
+        for (const candidate of candidates) {
+            const result = await this.evaluateCandidate(candidate);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * Evaluate a single candidate
+     */
+    async evaluateCandidate(candidate) {
+        const filePath = path.isAbsolute(candidate.file)
+            ? candidate.file
+            : path.join(this.config.workingDirectory, candidate.file);
+        // Special case: npm install command
+        if (candidate.fixed.startsWith('npm install')) {
+            const installResult = await (0, bash_js_1.bash)(candidate.fixed, {
+                cwd: this.config.workingDirectory,
+                timeout: 60000,
+            });
+            return {
+                candidate,
+                testsPass: installResult.success,
+                testsPassed: installResult.success ? 1 : 0,
+                testsTotal: 1,
+                buildSuccess: installResult.success,
+                newErrors: [],
+                fixedErrors: [],
+                score: installResult.success ? 1 : 0,
+            };
+        }
+        // Create backup
+        let backup;
+        if (this.config.createBackup && fs.existsSync(filePath)) {
+            backup = candidate.original;
+        }
+        // Apply fix temporarily
+        try {
+            fs.writeFileSync(filePath, candidate.fixed, 'utf-8');
+        }
+        catch {
+            return {
+                candidate,
+                testsPass: false,
+                testsPassed: 0,
+                testsTotal: 0,
+                buildSuccess: false,
+                newErrors: [],
+                fixedErrors: [],
+                score: 0,
+            };
+        }
+        // Run build
+        const buildResult = await (0, bash_js_1.bash)(this.config.buildCommand, {
+            cwd: this.config.workingDirectory,
+            timeout: 60000,
+        });
+        // Detect new errors
+        const buildErrors = (0, detector_js_1.detectErrors)(buildResult.stdout + '\n' + buildResult.stderr);
+        // Run tests if build succeeded
+        let testResult;
+        let testErrors = { errors: [], success: true };
+        if (buildResult.success) {
+            testResult = await (0, bash_js_1.bash)(this.config.testCommand, {
+                cwd: this.config.workingDirectory,
+                timeout: 120000,
+            });
+            testErrors = (0, detector_js_1.detectErrors)(testResult.stdout + '\n' + testResult.stderr);
+        }
+        // Restore original
+        if (backup !== undefined) {
+            fs.writeFileSync(filePath, backup, 'utf-8');
+        }
+        // Calculate score
+        const newErrors = [...buildErrors.errors, ...testErrors.errors];
+        const score = this.calculateScore(buildResult.success, testResult?.success || false, newErrors.length);
+        return {
+            candidate,
+            testsPass: testResult?.success || false,
+            testsPassed: testResult?.success ? 1 : 0, // Simplified
+            testsTotal: 1,
+            buildSuccess: buildResult.success,
+            newErrors,
+            fixedErrors: [], // Would need to compare with original errors
+            score,
+        };
+    }
+    /**
+     * Calculate evaluation score
+     */
+    calculateScore(buildSuccess, testsPass, newErrorCount) {
+        let score = 0;
+        if (buildSuccess)
+            score += 0.4;
+        if (testsPass)
+            score += 0.4;
+        score += Math.max(0, 0.2 - (newErrorCount * 0.05)); // Penalize new errors
+        return Math.max(0, Math.min(1, score));
+    }
+    // --------------------------------------------------------------------------
+    // Selection and Application
+    // --------------------------------------------------------------------------
+    /**
+     * Select the best candidate from evaluations
+     */
+    selectBest(evaluations) {
+        if (evaluations.length === 0)
+            return null;
+        return evaluations.reduce((best, current) => {
+            if (!best)
+                return current;
+            return current.score > best.score ? current : best;
+        }, null);
+    }
+    /**
+     * Apply a fix permanently
+     */
+    async applyFix(candidate) {
+        // Special case: npm install command
+        if (candidate.fixed.startsWith('npm install')) {
+            const result = await (0, bash_js_1.bash)(candidate.fixed, {
+                cwd: this.config.workingDirectory,
+                timeout: 60000,
+            });
+            return result.success;
+        }
+        const filePath = path.isAbsolute(candidate.file)
+            ? candidate.file
+            : path.join(this.config.workingDirectory, candidate.file);
+        try {
+            // Use edit tool for atomic write with backup
+            const result = await (0, edit_js_1.edit)({
+                file_path: filePath,
+                old_string: candidate.original,
+                new_string: candidate.fixed,
+            });
+            return result.success;
+        }
+        catch {
+            return false;
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Configuration
+    // --------------------------------------------------------------------------
+    getConfig() {
+        return { ...this.config };
+    }
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Add a custom fix pattern
+     */
+    addPattern(pattern) {
+        this.patterns.push(pattern);
+    }
+    /**
+     * Set LLM fix generator
+     */
+    setLLMGenerator(generator) {
+        this.config.llmFixGenerator = generator;
+    }
+}
+exports.AutoFixer = AutoFixer;
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+let fixerInstance = null;
+function getAutoFixer(config) {
+    if (!fixerInstance) {
+        fixerInstance = new AutoFixer(config);
+    }
+    else if (config) {
+        fixerInstance.updateConfig(config);
+    }
+    return fixerInstance;
+}
+function resetAutoFixer() {
+    fixerInstance = null;
+}
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Attempt to fix errors in output
+ */
+async function autoFix(output, config) {
+    const errors = (0, detector_js_1.detectErrors)(output).errors.filter(e => e.severity === 'error');
+    return getAutoFixer(config).fix(errors);
+}
+/**
+ * Generate fix candidates for an error
+ */
+async function generateFixes(error) {
+    return getAutoFixer().generateCandidates([error]);
+}

package/dist/src/healing/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Genesis Self-Healing Module
+ *
+ * Darwin-Gödel pattern for automatic error recovery:
+ * - Detect errors from command output
+ * - Generate fix candidates
+ * - Evaluate and select best fix
+ * - Apply and verify
+ */
+export * from './detector.js';
+export * from './fixer.js';
+import { detectErrors, hasErrors, formatErrorReport, getErrorDetector } from './detector.js';
+import { autoFix, generateFixes, getAutoFixer } from './fixer.js';
+export declare const healing: {
+    detectErrors: typeof detectErrors;
+    hasErrors: typeof hasErrors;
+    formatErrorReport: typeof formatErrorReport;
+    getDetector: typeof getErrorDetector;
+    autoFix: typeof autoFix;
+    generateFixes: typeof generateFixes;
+    getFixer: typeof getAutoFixer;
+};
+export default healing;

package/dist/src/healing/index.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Genesis Self-Healing Module
+ *
+ * Darwin-Gödel pattern for automatic error recovery:
+ * - Detect errors from command output
+ * - Generate fix candidates
+ * - Evaluate and select best fix
+ * - Apply and verify
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.healing = void 0;
+__exportStar(require("./detector.js"), exports);
+__exportStar(require("./fixer.js"), exports);
+// Re-export main functions for convenience
+const detector_js_1 = require("./detector.js");
+const fixer_js_1 = require("./fixer.js");
+exports.healing = {
+    // Detection
+    detectErrors: detector_js_1.detectErrors,
+    hasErrors: detector_js_1.hasErrors,
+    formatErrorReport: detector_js_1.formatErrorReport,
+    getDetector: detector_js_1.getErrorDetector,
+    // Fixing
+    autoFix: fixer_js_1.autoFix,
+    generateFixes: fixer_js_1.generateFixes,
+    getFixer: fixer_js_1.getAutoFixer,
+};
+exports.default = exports.healing;