erosolar-cli 2.1.249 → 2.1.252

package/dist/core/selfImprovement.js

@@ -1,700 +1,25 @@
 /**
- * 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
+ * Self Improvement - Minimal stub for backward compatibility
  */
-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;
+export function analyzeImprovementOpportunities(_workingDir) {
+    return [];
 }
-// ============================================================================
-// 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;
-    }
+export async function runSelfImprovementCycle(_workingDir, _options) {
+    return { summary: 'No improvements available (feature deprecated)', applied: 0, results: [] };
 }
-/**
- * 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;
+export function getImprovementSummary(_workingDir) {
+    return 'No improvement data available (feature deprecated)';
 }
-/**
- * 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 };
+export async function runAutonomousImprovement(_options) {
+    return { iterations: 0, totalApplied: 0, totalFailed: 0, totalRollbacks: 0, stoppedReason: 'Feature deprecated' };
 }
-/**
- * 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) };
-    }
+    // No-op stub
 }
-/**
- * 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;
-    }
+export function getAutoImprovementState() {
+    return { running: false, isRunning: false, iteration: 0 };
 }
-/**
- * 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)}`,
-        };
-    }
+export function emergencyRollback(_workingDir) {
+    return { success: true, message: 'No rollback needed (feature deprecated)' };
 }
 //# sourceMappingURL=selfImprovement.js.map