erosolar-cli 1.7.439 → 1.7.440

package/dist/core/selfImprovement.js

@@ -0,0 +1,700 @@
+/**
+ * Self-Improvement Orchestrator
+ *
+ * Applies AlphaZero-style learning to complex debugging, refactoring, and
+ * precision tasks to continuously improve erosolar-cli source code.
+ *
+ * Features:
+ * 1. Identifies improvement opportunities from learning data
+ * 2. Applies quality-driven code changes
+ * 3. Uses git for safe versioning and rollback
+ * 4. Validates changes before committing
+ *
+ * Principal Investigator: Bo Shang
+ */
+import { execSync, exec } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { getLearningSummary, loadFailurePatterns, loadToolPatterns, } from './learningPersistence.js';
+import { getSourceCodeFixes, } from './failureRecovery.js';
+const execAsync = promisify(exec);
+// ============================================================================
+// IMPROVEMENT DETECTION
+// ============================================================================
+/**
+ * Analyze learning data to identify improvement opportunities
+ */
+export function analyzeImprovementOpportunities(workingDir = process.cwd()) {
+    const opportunities = [];
+    // 1. Analyze failure patterns for bug fixes
+    const failurePatterns = loadFailurePatterns();
+    for (const pattern of failurePatterns.patterns) {
+        if (pattern.occurrences >= 2) {
+            // This failure has occurred multiple times - worth fixing
+            opportunities.push({
+                type: 'bug-fix',
+                priority: pattern.occurrences >= 5 ? 'high' : 'medium',
+                description: `Fix recurring issue: ${pattern.description.slice(0, 100)}`,
+                sourceFile: 'src/core',
+                suggestedChange: pattern.avoidanceHint || 'Apply learned fix',
+                confidence: Math.min(0.95, pattern.occurrences / 10 + 0.5),
+                evidence: [`Occurred ${pattern.occurrences} times`, `Last seen: ${pattern.lastSeen}`],
+            });
+        }
+    }
+    // 2. Analyze source code fixes from recovery system
+    const sourceFixes = getSourceCodeFixes();
+    for (const fix of sourceFixes) {
+        if (fix.validatedCount >= 2 && !fix.appliedToSource) {
+            opportunities.push({
+                type: 'bug-fix',
+                priority: fix.failureType === 'build' ? 'critical' : 'high',
+                description: fix.description,
+                sourceFile: fix.filePath,
+                suggestedChange: `Replace:\n${fix.originalCode.slice(0, 200)}...\nWith:\n${fix.fixedCode.slice(0, 200)}...`,
+                confidence: Math.min(0.95, fix.validatedCount / 5 + 0.6),
+                evidence: [`Validated ${fix.validatedCount} times`, `Failure type: ${fix.failureType}`],
+            });
+        }
+    }
+    // 3. Analyze tool patterns for optimization opportunities
+    const toolPatterns = loadToolPatterns();
+    for (const [taskType, patterns] of Object.entries(toolPatterns.patterns)) {
+        const inefficient = patterns.filter(p => p.successRate < 0.7 && p.occurrences >= 3);
+        if (inefficient.length > 0) {
+            opportunities.push({
+                type: 'performance',
+                priority: 'medium',
+                description: `Optimize tool handling for ${taskType} tasks`,
+                sourceFile: 'src/core/toolRuntime.ts',
+                suggestedChange: 'Add caching or improve tool selection logic',
+                confidence: 0.6,
+                evidence: inefficient.map(p => `Pattern ${p.toolSequence.join('→')} has ${Math.round(p.successRate * 100)}% success`),
+            });
+        }
+    }
+    // Sort by priority and confidence
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    opportunities.sort((a, b) => {
+        const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+        if (priorityDiff !== 0)
+            return priorityDiff;
+        return b.confidence - a.confidence;
+    });
+    return opportunities;
+}
+// ============================================================================
+// GIT OPERATIONS
+// ============================================================================
+/**
+ * Check if working directory is clean
+ */
+function isGitClean(workingDir) {
+    try {
+        const result = execSync('git status --porcelain', { cwd: workingDir, encoding: 'utf-8' });
+        return result.trim() === '';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create a new branch for self-improvement changes
+ */
+function createImprovementBranch(workingDir, description) {
+    const timestamp = Date.now();
+    const safeName = description.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 30);
+    const branchName = `self-improve/${safeName}-${timestamp}`;
+    execSync(`git checkout -b ${branchName}`, { cwd: workingDir, encoding: 'utf-8' });
+    return branchName;
+}
+/**
+ * Commit changes with descriptive message
+ */
+function commitChanges(workingDir, files, message) {
+    for (const file of files) {
+        execSync(`git add "${file}"`, { cwd: workingDir, encoding: 'utf-8' });
+    }
+    const fullMessage = `[self-improvement] ${message}
+
+Applied by AlphaZero self-improvement system.
+Run \`git revert HEAD\` to rollback.
+
+🤖 Generated with erosolar-cli self-improvement`;
+    execSync(`git commit -m "${fullMessage.replace(/"/g, '\\"')}"`, { cwd: workingDir, encoding: 'utf-8' });
+    const hash = execSync('git rev-parse HEAD', { cwd: workingDir, encoding: 'utf-8' }).trim();
+    return hash;
+}
+/**
+ * Run validation (build and optional tests)
+ */
+async function validateChanges(workingDir, runTests) {
+    let buildPassed = false;
+    let testsPassed = false;
+    try {
+        await execAsync('npm run build', { cwd: workingDir });
+        buildPassed = true;
+    }
+    catch {
+        buildPassed = false;
+        return { buildPassed, testsPassed };
+    }
+    if (runTests) {
+        try {
+            await execAsync('npm test', { cwd: workingDir, timeout: 120000 });
+            testsPassed = true;
+        }
+        catch {
+            testsPassed = false;
+        }
+    }
+    else {
+        testsPassed = true; // Skip tests, consider passed
+    }
+    return { buildPassed, testsPassed };
+}
+/**
+ * Rollback changes
+ */
+function rollbackChanges(workingDir, originalBranch) {
+    execSync('git checkout .', { cwd: workingDir });
+    execSync(`git checkout ${originalBranch}`, { cwd: workingDir });
+}
+// ============================================================================
+// IMPROVEMENT APPLICATION
+// ============================================================================
+/**
+ * Apply a source code fix
+ */
+function applySourceFix(fix, workingDir) {
+    const fullPath = join(workingDir, fix.filePath);
+    if (!existsSync(fullPath)) {
+        return false;
+    }
+    const content = readFileSync(fullPath, 'utf-8');
+    if (!content.includes(fix.originalCode)) {
+        // Code has changed, can't apply fix
+        return false;
+    }
+    const newContent = content.replace(fix.originalCode, fix.fixedCode);
+    writeFileSync(fullPath, newContent);
+    return true;
+}
+/**
+ * Execute a self-improvement plan
+ */
+export async function executeImprovementPlan(plan, workingDir = process.cwd(), options = {}) {
+    const { runTests = true, autoCommit = true, dryRun = false } = options;
+    const result = {
+        success: false,
+        filesChanged: [],
+        testsRun: runTests,
+        testsPassed: false,
+        buildPassed: false,
+    };
+    if (dryRun) {
+        // Just report what would be done
+        return {
+            ...result,
+            success: true,
+            filesChanged: plan.opportunities.map(o => o.sourceFile),
+        };
+    }
+    // Check git status
+    if (!isGitClean(workingDir)) {
+        result.error = 'Working directory has uncommitted changes. Please commit or stash them first.';
+        return result;
+    }
+    // Get current branch
+    const originalBranch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: workingDir, encoding: 'utf-8' }).trim();
+    try {
+        // Create improvement branch
+        const branchName = createImprovementBranch(workingDir, `improve-${plan.id}`);
+        // Apply source code fixes
+        const sourceFixes = getSourceCodeFixes();
+        for (const opportunity of plan.opportunities) {
+            if (opportunity.type === 'bug-fix') {
+                const matchingFix = sourceFixes.find(f => f.filePath === opportunity.sourceFile ||
+                    f.description === opportunity.description);
+                if (matchingFix) {
+                    const applied = applySourceFix(matchingFix, workingDir);
+                    if (applied) {
+                        result.filesChanged.push(opportunity.sourceFile);
+                    }
+                }
+            }
+        }
+        if (result.filesChanged.length === 0) {
+            // Nothing to apply
+            rollbackChanges(workingDir, originalBranch);
+            result.error = 'No applicable changes found';
+            return result;
+        }
+        // Validate changes
+        const validation = await validateChanges(workingDir, runTests);
+        result.buildPassed = validation.buildPassed;
+        result.testsPassed = validation.testsPassed;
+        if (!validation.buildPassed) {
+            rollbackChanges(workingDir, originalBranch);
+            result.error = 'Build failed after applying changes';
+            return result;
+        }
+        if (runTests && !validation.testsPassed) {
+            rollbackChanges(workingDir, originalBranch);
+            result.error = 'Tests failed after applying changes';
+            return result;
+        }
+        // Commit changes
+        if (autoCommit) {
+            const description = plan.opportunities.map(o => o.description).join('; ').slice(0, 100);
+            result.commitHash = commitChanges(workingDir, result.filesChanged, description);
+            result.rollbackCommand = `git revert ${result.commitHash}`;
+        }
+        result.success = true;
+        // Merge back to original branch if successful
+        execSync(`git checkout ${originalBranch}`, { cwd: workingDir });
+        execSync(`git merge ${branchName}`, { cwd: workingDir });
+        return result;
+    }
+    catch (error) {
+        // Rollback on any error
+        try {
+            rollbackChanges(workingDir, originalBranch);
+        }
+        catch {
+            // Ignore rollback errors
+        }
+        result.error = error instanceof Error ? error.message : String(error);
+        return result;
+    }
+}
+// ============================================================================
+// SELF-IMPROVEMENT TRIGGERS
+// ============================================================================
+/**
+ * Trigger self-improvement for complex debugging task
+ */
+export async function triggerDebugImprovement(errorPattern, workingDir = process.cwd()) {
+    const opportunities = analyzeImprovementOpportunities(workingDir);
+    // Filter for relevant opportunities
+    const relevant = opportunities.filter(o => o.type === 'bug-fix' &&
+        (o.description.toLowerCase().includes(errorPattern.toLowerCase()) ||
+            o.evidence.some(e => e.toLowerCase().includes(errorPattern.toLowerCase()))));
+    if (relevant.length === 0) {
+        return null;
+    }
+    const plan = {
+        id: `debug-${Date.now()}`,
+        opportunities: relevant,
+        totalConfidence: relevant.reduce((sum, o) => sum + o.confidence, 0) / relevant.length,
+        estimatedImpact: 'Fix recurring debugging issues',
+        createdAt: new Date().toISOString(),
+    };
+    return executeImprovementPlan(plan, workingDir);
+}
+/**
+ * Trigger self-improvement for refactoring task
+ */
+export async function triggerRefactorImprovement(targetArea, workingDir = process.cwd()) {
+    const opportunities = analyzeImprovementOpportunities(workingDir);
+    const relevant = opportunities.filter(o => o.type === 'refactor' || o.type === 'performance');
+    if (relevant.length === 0) {
+        return null;
+    }
+    const plan = {
+        id: `refactor-${Date.now()}`,
+        opportunities: relevant.slice(0, 5), // Limit to top 5
+        totalConfidence: relevant.reduce((sum, o) => sum + o.confidence, 0) / relevant.length,
+        estimatedImpact: 'Improve code quality and performance',
+        createdAt: new Date().toISOString(),
+    };
+    return executeImprovementPlan(plan, workingDir);
+}
+/**
+ * Run comprehensive self-improvement analysis
+ */
+export async function runSelfImprovementCycle(workingDir = process.cwd(), options = {}) {
+    const { maxChanges = 3, minConfidence = 0.7, runTests = true, autoCommit = true } = options;
+    const opportunities = analyzeImprovementOpportunities(workingDir);
+    const filtered = opportunities.filter(o => o.confidence >= minConfidence);
+    const toApply = filtered.slice(0, maxChanges);
+    const results = [];
+    for (const opportunity of toApply) {
+        const plan = {
+            id: `single-${Date.now()}`,
+            opportunities: [opportunity],
+            totalConfidence: opportunity.confidence,
+            estimatedImpact: opportunity.description,
+            createdAt: new Date().toISOString(),
+        };
+        const result = await executeImprovementPlan(plan, workingDir, { runTests, autoCommit });
+        results.push(result);
+        // Stop if any improvement fails
+        if (!result.success) {
+            break;
+        }
+    }
+    const applied = results.filter(r => r.success).length;
+    return {
+        analyzed: opportunities.length,
+        applied,
+        results,
+        summary: `Analyzed ${opportunities.length} opportunities, filtered to ${filtered.length} (confidence >= ${minConfidence}), applied ${applied}/${toApply.length}`,
+    };
+}
+// ============================================================================
+// CLI INTEGRATION
+// ============================================================================
+/**
+ * Get a summary of improvement opportunities for display
+ */
+export function getImprovementSummary(workingDir = process.cwd()) {
+    const opportunities = analyzeImprovementOpportunities(workingDir);
+    const learning = getLearningSummary();
+    const lines = [];
+    lines.push('🧠 Self-Improvement Analysis');
+    lines.push('');
+    lines.push(`Learning Data:`);
+    lines.push(`  - Tool patterns: ${learning.toolPatterns.totalPatterns}`);
+    lines.push(`  - Failure patterns: ${learning.failurePatterns.totalPatterns}`);
+    lines.push(`  - Prompt improvements: ${learning.promptImprovements.totalImprovements}`);
+    lines.push('');
+    lines.push(`Improvement Opportunities: ${opportunities.length}`);
+    if (opportunities.length > 0) {
+        lines.push('');
+        const top = opportunities.slice(0, 5);
+        for (const opp of top) {
+            const icon = opp.type === 'bug-fix' ? '🐛' : opp.type === 'refactor' ? '🔧' : '⚡';
+            lines.push(`  ${icon} [${opp.priority}] ${opp.description.slice(0, 60)}...`);
+            lines.push(`     Confidence: ${Math.round(opp.confidence * 100)}% | File: ${opp.sourceFile}`);
+        }
+        if (opportunities.length > 5) {
+            lines.push(`  ... and ${opportunities.length - 5} more`);
+        }
+    }
+    lines.push('');
+    lines.push('Commands:');
+    lines.push('  /improve analyze  - Analyze improvement opportunities');
+    lines.push('  /improve apply    - Apply high-confidence improvements');
+    lines.push('  /improve dry-run  - Preview changes without applying');
+    lines.push('  /improve auto     - Run autonomous infinite improvement (Ctrl+C to stop)');
+    return lines.join('\n');
+}
+// Global state for autonomous improvement
+let autoImprovementState = {
+    isRunning: false,
+    startTime: null,
+    iteration: 0,
+    applied: 0,
+    failed: 0,
+    rollbacks: 0,
+    lastError: null,
+    safetyBranchBase: null,
+};
+/**
+ * Get current auto-improvement state
+ */
+export function getAutoImprovementState() {
+    return { ...autoImprovementState };
+}
+/**
+ * Request stop of autonomous improvement
+ */
+export function requestAutoImprovementStop() {
+    autoImprovementState.isRunning = false;
+}
+/**
+ * Create a safety checkpoint before autonomous improvement
+ */
+function createSafetyCheckpoint(workingDir) {
+    try {
+        // Ensure clean working directory
+        const status = execSync('git status --porcelain', { cwd: workingDir, encoding: 'utf-8' }).trim();
+        if (status) {
+            // Stash any uncommitted changes
+            execSync('git stash push -m "auto-improve-safety-stash"', { cwd: workingDir, encoding: 'utf-8' });
+        }
+        // Get current branch
+        const currentBranch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: workingDir, encoding: 'utf-8' }).trim();
+        // Create safety tag
+        const timestamp = Date.now();
+        const safetyTag = `auto-improve-checkpoint-${timestamp}`;
+        execSync(`git tag ${safetyTag}`, { cwd: workingDir, encoding: 'utf-8' });
+        return { success: true, branch: currentBranch };
+    }
+    catch (error) {
+        return { success: false, branch: '', error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/**
+ * Rollback to safety checkpoint
+ */
+function rollbackToCheckpoint(workingDir, originalBranch) {
+    try {
+        // Find the most recent safety tag
+        const tags = execSync('git tag -l "auto-improve-checkpoint-*" --sort=-version:refname', {
+            cwd: workingDir,
+            encoding: 'utf-8',
+        }).trim().split('\n');
+        if (tags.length > 0 && tags[0]) {
+            // Hard reset to the checkpoint
+            execSync(`git reset --hard ${tags[0]}`, { cwd: workingDir, encoding: 'utf-8' });
+            // Try to restore stashed changes
+            try {
+                execSync('git stash pop', { cwd: workingDir, encoding: 'utf-8' });
+            }
+            catch {
+                // No stash to pop, that's fine
+            }
+            return { success: true };
+        }
+        return { success: false, error: 'No checkpoint found' };
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/**
+ * Run autonomous infinite improvement
+ *
+ * This function runs in a loop, continuously:
+ * 1. Analyzing improvement opportunities
+ * 2. Applying the highest-confidence improvement
+ * 3. Validating with build/tests
+ * 4. Rolling back if validation fails
+ * 5. Continuing until no more improvements or stopped
+ */
+export async function runAutonomousImprovement(config) {
+    const { workingDir, minConfidence = 0.75, maxIterations = 100, delayBetweenMs = 2000, runTests = true, onProgress, shouldStop, } = config;
+    // Reset state
+    autoImprovementState = {
+        isRunning: true,
+        startTime: new Date().toISOString(),
+        iteration: 0,
+        applied: 0,
+        failed: 0,
+        rollbacks: 0,
+        lastError: null,
+        safetyBranchBase: null,
+    };
+    // Create safety checkpoint
+    const checkpoint = createSafetyCheckpoint(workingDir);
+    if (!checkpoint.success) {
+        onProgress?.({
+            type: 'failed',
+            message: `Failed to create safety checkpoint: ${checkpoint.error}`,
+        });
+        autoImprovementState.isRunning = false;
+        return {
+            success: false,
+            totalApplied: 0,
+            totalFailed: 0,
+            totalRollbacks: 0,
+            iterations: 0,
+            stoppedReason: 'error',
+            error: checkpoint.error,
+        };
+    }
+    autoImprovementState.safetyBranchBase = checkpoint.branch;
+    onProgress?.({
+        type: 'start',
+        message: `Starting autonomous improvement. Safety checkpoint created. Press Ctrl+C to stop.`,
+    });
+    let consecutiveFailures = 0;
+    const MAX_CONSECUTIVE_FAILURES = 3;
+    try {
+        while (autoImprovementState.isRunning && autoImprovementState.iteration < maxIterations) {
+            // Check for stop request
+            if (shouldStop?.() || !autoImprovementState.isRunning) {
+                onProgress?.({
+                    type: 'complete',
+                    message: 'Stopped by user request',
+                    totalApplied: autoImprovementState.applied,
+                    totalFailed: autoImprovementState.failed,
+                });
+                return {
+                    success: true,
+                    totalApplied: autoImprovementState.applied,
+                    totalFailed: autoImprovementState.failed,
+                    totalRollbacks: autoImprovementState.rollbacks,
+                    iterations: autoImprovementState.iteration,
+                    stoppedReason: 'user-stopped',
+                };
+            }
+            autoImprovementState.iteration++;
+            onProgress?.({
+                type: 'iteration',
+                iteration: autoImprovementState.iteration,
+                message: `Iteration ${autoImprovementState.iteration}: Analyzing opportunities...`,
+            });
+            // Analyze opportunities
+            const opportunities = analyzeImprovementOpportunities(workingDir);
+            const filtered = opportunities.filter(o => o.confidence >= minConfidence);
+            if (filtered.length === 0) {
+                onProgress?.({
+                    type: 'no-opportunities',
+                    message: `No improvements found with confidence >= ${Math.round(minConfidence * 100)}%. Stopping.`,
+                    totalApplied: autoImprovementState.applied,
+                });
+                return {
+                    success: true,
+                    totalApplied: autoImprovementState.applied,
+                    totalFailed: autoImprovementState.failed,
+                    totalRollbacks: autoImprovementState.rollbacks,
+                    iterations: autoImprovementState.iteration,
+                    stoppedReason: 'no-opportunities',
+                };
+            }
+            // Take the highest-confidence opportunity
+            const opportunity = filtered[0];
+            onProgress?.({
+                type: 'iteration',
+                iteration: autoImprovementState.iteration,
+                message: `Found ${filtered.length} opportunities. Applying: ${opportunity.description.slice(0, 50)}...`,
+                opportunity,
+            });
+            // Create improvement plan for single opportunity
+            const plan = {
+                id: `auto-${autoImprovementState.iteration}-${Date.now()}`,
+                opportunities: [opportunity],
+                totalConfidence: opportunity.confidence,
+                estimatedImpact: opportunity.description,
+                createdAt: new Date().toISOString(),
+            };
+            // Execute the improvement
+            const result = await executeImprovementPlan(plan, workingDir, {
+                runTests,
+                autoCommit: true,
+                dryRun: false,
+            });
+            if (result.success) {
+                autoImprovementState.applied++;
+                consecutiveFailures = 0;
+                onProgress?.({
+                    type: 'applied',
+                    iteration: autoImprovementState.iteration,
+                    message: `✅ Applied: ${opportunity.description.slice(0, 50)}`,
+                    opportunity,
+                    result,
+                    totalApplied: autoImprovementState.applied,
+                });
+            }
+            else {
+                autoImprovementState.failed++;
+                consecutiveFailures++;
+                autoImprovementState.lastError = result.error ?? 'Unknown error';
+                onProgress?.({
+                    type: 'failed',
+                    iteration: autoImprovementState.iteration,
+                    message: `❌ Failed: ${result.error}`,
+                    opportunity,
+                    result,
+                    totalFailed: autoImprovementState.failed,
+                });
+                // If too many consecutive failures, stop
+                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                    onProgress?.({
+                        type: 'complete',
+                        message: `Stopping after ${MAX_CONSECUTIVE_FAILURES} consecutive failures.`,
+                        totalApplied: autoImprovementState.applied,
+                        totalFailed: autoImprovementState.failed,
+                    });
+                    return {
+                        success: false,
+                        totalApplied: autoImprovementState.applied,
+                        totalFailed: autoImprovementState.failed,
+                        totalRollbacks: autoImprovementState.rollbacks,
+                        iterations: autoImprovementState.iteration,
+                        stoppedReason: 'error',
+                        error: `Stopped after ${MAX_CONSECUTIVE_FAILURES} consecutive failures`,
+                    };
+                }
+            }
+            // Delay between iterations to avoid overwhelming the system
+            await new Promise(resolve => setTimeout(resolve, delayBetweenMs));
+        }
+        // Reached max iterations
+        onProgress?.({
+            type: 'complete',
+            message: `Reached maximum iterations (${maxIterations})`,
+            totalApplied: autoImprovementState.applied,
+            totalFailed: autoImprovementState.failed,
+        });
+        return {
+            success: true,
+            totalApplied: autoImprovementState.applied,
+            totalFailed: autoImprovementState.failed,
+            totalRollbacks: autoImprovementState.rollbacks,
+            iterations: autoImprovementState.iteration,
+            stoppedReason: 'max-iterations',
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        autoImprovementState.lastError = errorMessage;
+        onProgress?.({
+            type: 'failed',
+            message: `Fatal error: ${errorMessage}. Rolling back to checkpoint...`,
+        });
+        // Rollback on fatal error
+        const rollbackResult = rollbackToCheckpoint(workingDir, checkpoint.branch);
+        if (rollbackResult.success) {
+            autoImprovementState.rollbacks++;
+            onProgress?.({
+                type: 'rollback',
+                message: 'Successfully rolled back to safety checkpoint',
+            });
+        }
+        return {
+            success: false,
+            totalApplied: autoImprovementState.applied,
+            totalFailed: autoImprovementState.failed,
+            totalRollbacks: autoImprovementState.rollbacks,
+            iterations: autoImprovementState.iteration,
+            stoppedReason: 'error',
+            error: errorMessage,
+        };
+    }
+    finally {
+        autoImprovementState.isRunning = false;
+    }
+}
+/**
+ * Emergency rollback - use if something goes wrong
+ */
+export function emergencyRollback(workingDir) {
+    try {
+        // Find the most recent safety checkpoint
+        const tags = execSync('git tag -l "auto-improve-checkpoint-*" --sort=-version:refname', {
+            cwd: workingDir,
+            encoding: 'utf-8',
+        }).trim().split('\n');
+        if (tags.length === 0 || !tags[0]) {
+            return { success: false, message: 'No safety checkpoint found' };
+        }
+        const checkpoint = tags[0];
+        // Hard reset to checkpoint
+        execSync(`git reset --hard ${checkpoint}`, { cwd: workingDir, encoding: 'utf-8' });
+        // Clean up the tag
+        execSync(`git tag -d ${checkpoint}`, { cwd: workingDir, encoding: 'utf-8' });
+        // Rebuild
+        try {
+            execSync('npm run build', { cwd: workingDir, encoding: 'utf-8' });
+        }
+        catch {
+            // Build might fail, that's okay for emergency rollback
+        }
+        return {
+            success: true,
+            message: `Rolled back to checkpoint ${checkpoint}. Run 'npm run build' to rebuild.`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Rollback failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+//# sourceMappingURL=selfImprovement.js.map