erosolar-cli 2.1.249 → 2.1.252

package/dist/core/selfEvolution.js

@@ -1,981 +1,38 @@
 /**
- * Self-Evolution System for erosolar-cli
- *
- * When erosolar-cli is run in its own source repository, this module enables
- * fully automatic self-improvement using AlphaZero-style techniques.
- *
- * The system:
- * 1. Analyzes its own source code for improvement opportunities
- * 2. Generates fixes using dual-response + self-critique
- * 3. Validates with build + tests
- * 4. Commits successful changes
- * 5. Relaunches to run the improved version
- * 6. Continues until no more improvements found
- *
- * Safety:
- * - Git checkpoint before any changes
- * - Every change validated with build + tests
- * - Automatic rollback on any failure
- * - Max iterations to prevent infinite loops
- * - Human-readable commit messages
- *
- * Principal Investigator: Bo Shang
+ * Self Evolution - Minimal stub for backward compatibility
  */
-import { execSync, spawn } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { homedir } from 'node:os';
-// ============================================================================
-// CONSTANTS
-// ============================================================================
-const DEFAULT_CONFIG = {
-    maxIterations: 50,
-    minConfidence: 0.8,
-    runTests: true,
-    autoRelaunch: true,
-    verboseLogging: true,
-    targetAreas: ['bugs', 'types', 'performance'],
-    priorityPaths: ['tools', 'core', 'providers', 'mcp', 'subagents'], // Critical modular parts first
-    anyRepo: true, // Now works on any repo
-};
-// File priority scoring - higher means more important to fix first
-const FILE_PRIORITY_MAP = {
-    'tools': 100, // Tool source code - highest priority
-    'core': 90, // Core functionality
-    'providers': 85, // Provider integrations
-    'mcp': 80, // MCP servers
-    'subagents': 75, // Subagent implementations
-    'capabilities': 70,
-    'runtime': 65,
-    'shell': 60,
-    'ui': 50,
-    'config': 45,
-    'utils': 40,
-    'tests': 30,
-};
-const STATE_FILE = join(homedir(), '.erosolar', 'evolution-state.json');
-const EVOLUTION_LOG = join(homedir(), '.erosolar', 'evolution.log');
-// Known patterns to look for in erosolar-cli source
-const SOURCE_PATTERNS = {
-    typeErrors: [
-        /as\s+any\b/g, // Unsafe type assertions
-        /\/\/\s*@ts-ignore/g, // Type suppressions
-        /\/\/\s*@ts-expect-error/g, // Expected errors
-        /:\s*any\b/g, // Explicit any types
-    ],
-    bugs: [
-        /catch\s*\(\s*\)\s*\{/g, // Empty catch blocks
-        /console\.(log|warn|error)\(/g, // Debug statements
-        /TODO|FIXME|HACK|XXX/gi, // Code markers
-        /throw\s+new\s+Error\s*\(\s*\)/g, // Empty error messages
-    ],
-    performance: [
-        /\.forEach\s*\(/g, // forEach (consider for...of)
-        /JSON\.parse\(JSON\.stringify/g, // Deep clone antipattern
-        /new\s+RegExp\(/g, // Dynamic regex (could be static)
-    ],
-};
-// ============================================================================
-// STATE MANAGEMENT
-// ============================================================================
-let evolutionState = {
-    isRunning: false,
-    startTime: null,
-    iteration: 0,
-    totalFixed: 0,
-    totalFailed: 0,
-    checkpointTag: null,
-    lastCommit: null,
-    relaunchCount: 0,
-};
-function loadState() {
-    try {
-        if (existsSync(STATE_FILE)) {
-            return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
-        }
-    }
-    catch {
-        // Ignore
-    }
-    return evolutionState;
+export function isValidSourceRepo(_path) {
+    return false;
 }
-function saveState() {
-    const dir = join(homedir(), '.erosolar');
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(STATE_FILE, JSON.stringify(evolutionState, null, 2));
+export function getRepoName(_path) {
+    return 'unknown';
 }
-function log(message) {
-    const timestamp = new Date().toISOString();
-    const line = `[${timestamp}] ${message}\n`;
-    // Append to log file
-    const dir = join(homedir(), '.erosolar');
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    try {
-        const existing = existsSync(EVOLUTION_LOG) ? readFileSync(EVOLUTION_LOG, 'utf-8') : '';
-        writeFileSync(EVOLUTION_LOG, existing + line);
-    }
-    catch {
-        // Ignore logging errors
-    }
-}
-// ============================================================================
-// DETECTION
-// ============================================================================
-/**
- * Check if we're running in the erosolar-cli source repository
- */
-export function isErosolarRepo(workingDir) {
-    try {
-        const packagePath = join(workingDir, 'package.json');
-        if (!existsSync(packagePath))
-            return false;
-        const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
-        return pkg.name === 'erosolar-cli';
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get the erosolar-cli version
- */
-export function getVersion(workingDir) {
-    try {
-        const packagePath = join(workingDir, 'package.json');
-        const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
-        return pkg.version ?? 'unknown';
-    }
-    catch {
-        return 'unknown';
-    }
-}
-// ============================================================================
-// SOURCE ANALYSIS
-// ============================================================================
-/**
- * Calculate priority score for a file based on its path
- */
-function getFilePriority(filePath) {
-    // Check each priority path
-    for (const [pathKey, priority] of Object.entries(FILE_PRIORITY_MAP)) {
-        if (filePath.includes(`/${pathKey}/`) || filePath.includes(`\\${pathKey}\\`) || filePath.startsWith(`${pathKey}/`)) {
-            return priority;
-        }
-    }
-    return 20; // Default priority for unclassified files
-}
-/**
- * Check if the directory is a valid git repository with source code
- */
-export function isValidSourceRepo(workingDir) {
-    try {
-        // Check for git
-        const gitDir = join(workingDir, '.git');
-        if (!existsSync(gitDir))
-            return false;
-        // Check for package.json or src directory
-        const packagePath = join(workingDir, 'package.json');
-        const srcDir = join(workingDir, 'src');
-        return existsSync(packagePath) || existsSync(srcDir);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get the repository name from package.json or directory name
- */
-export function getRepoName(workingDir) {
-    try {
-        const packagePath = join(workingDir, 'package.json');
-        if (existsSync(packagePath)) {
-            const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
-            if (pkg.name)
-                return pkg.name;
-        }
-    }
-    catch {
-        // Ignore
-    }
-    return workingDir.split(/[/\\]/).pop() ?? 'unknown';
-}
-/**
- * Analyze source code for improvement opportunities
- */
-export function analyzeSource(workingDir) {
-    const issues = [];
-    const srcDir = join(workingDir, 'src');
-    if (!existsSync(srcDir)) {
-        return issues;
-    }
-    // Recursively find all TypeScript files
-    const tsFiles = findFiles(srcDir, '.ts');
-    for (const file of tsFiles) {
-        const content = readFileSync(file, 'utf-8');
-        const relativePath = relative(workingDir, file);
-        const filePriority = getFilePriority(relativePath);
-        // Check for type issues
-        for (const pattern of SOURCE_PATTERNS.typeErrors) {
-            let match;
-            pattern.lastIndex = 0;
-            while ((match = pattern.exec(content)) !== null) {
-                const lineNum = content.slice(0, match.index).split('\n').length;
-                issues.push({
-                    type: 'type-error',
-                    severity: pattern.source.includes('any') ? 'medium' : 'low',
-                    file: relativePath,
-                    line: lineNum,
-                    description: `Found ${match[0]} - consider adding proper types`,
-                    confidence: 0.7,
-                    priority: filePriority,
-                });
-            }
-        }
-        // Check for bugs
-        for (const pattern of SOURCE_PATTERNS.bugs) {
-            let match;
-            pattern.lastIndex = 0;
-            while ((match = pattern.exec(content)) !== null) {
-                const lineNum = content.slice(0, match.index).split('\n').length;
-                const isTodo = /TODO|FIXME|HACK|XXX/i.test(match[0]);
-                issues.push({
-                    type: isTodo ? 'todo' : 'bug',
-                    severity: isTodo ? 'low' : 'medium',
-                    file: relativePath,
-                    line: lineNum,
-                    description: isTodo
-                        ? `Found ${match[0]} marker - needs attention`
-                        : `Found potential issue: ${match[0]}`,
-                    confidence: isTodo ? 0.9 : 0.6,
-                    priority: filePriority,
-                });
-            }
-        }
-        // Check for performance issues
-        for (const pattern of SOURCE_PATTERNS.performance) {
-            let match;
-            pattern.lastIndex = 0;
-            while ((match = pattern.exec(content)) !== null) {
-                const lineNum = content.slice(0, match.index).split('\n').length;
-                issues.push({
-                    type: 'performance',
-                    severity: 'low',
-                    file: relativePath,
-                    line: lineNum,
-                    description: `Performance: ${match[0]} could be optimized`,
-                    confidence: 0.5,
-                    priority: filePriority,
-                });
-            }
-        }
-    }
-    // Run TypeScript compiler to find real type errors
-    try {
-        execSync('npx tsc --noEmit 2>&1', { cwd: workingDir, encoding: 'utf-8' });
-    }
-    catch (error) {
-        if (error instanceof Error && 'stdout' in error) {
-            const output = error.stdout;
-            const errorLines = output.split('\n').filter(l => l.includes('error TS'));
-            for (const line of errorLines.slice(0, 20)) { // Limit to 20 errors
-                const match = line.match(/(.+)\((\d+),\d+\):\s*error\s+TS\d+:\s*(.+)/);
-                if (match) {
-                    const errorFile = match[1];
-                    issues.push({
-                        type: 'type-error',
-                        severity: 'high',
-                        file: errorFile,
-                        line: parseInt(match[2], 10),
-                        description: match[3],
-                        confidence: 1.0, // Real TypeScript errors
-                        priority: getFilePriority(errorFile),
-                    });
-                }
-            }
-        }
-    }
-    // Sort by priority first (higher = more important), then severity, then confidence
-    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-    issues.sort((a, b) => {
-        // Priority first (higher priority = should come first)
-        const prioDiff = b.priority - a.priority;
-        if (prioDiff !== 0)
-            return prioDiff;
-        // Then severity
-        const sevDiff = severityOrder[a.severity] - severityOrder[b.severity];
-        if (sevDiff !== 0)
-            return sevDiff;
-        // Then confidence
-        return b.confidence - a.confidence;
-    });
-    return issues;
-}
-function findFiles(dir, extension) {
-    const files = [];
-    try {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = join(dir, entry.name);
-            if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules' && entry.name !== 'dist') {
-                files.push(...findFiles(fullPath, extension));
-            }
-            else if (entry.isFile() && entry.name.endsWith(extension)) {
-                files.push(fullPath);
-            }
-        }
-    }
-    catch {
-        // Ignore directory access errors
-    }
-    return files;
-}
-// ============================================================================
-// GIT OPERATIONS
-// ============================================================================
-function createCheckpoint(workingDir) {
-    const timestamp = Date.now();
-    const tag = `evolution-checkpoint-${timestamp}`;
-    // Stash any uncommitted changes
-    try {
-        const status = execSync('git status --porcelain', { cwd: workingDir, encoding: 'utf-8' }).trim();
-        if (status) {
-            execSync('git stash push -m "evolution-auto-stash"', { cwd: workingDir, encoding: 'utf-8' });
-        }
-    }
-    catch {
-        // Ignore stash errors
-    }
-    // Create tag
-    execSync(`git tag ${tag}`, { cwd: workingDir, encoding: 'utf-8' });
-    return tag;
-}
-function rollbackToCheckpoint(workingDir, tag) {
-    try {
-        execSync(`git reset --hard ${tag}`, { cwd: workingDir, encoding: 'utf-8' });
-        execSync(`git tag -d ${tag}`, { cwd: workingDir, encoding: 'utf-8' });
-        // Try to restore stash
-        try {
-            execSync('git stash pop', { cwd: workingDir, encoding: 'utf-8' });
-        }
-        catch {
-            // No stash to pop
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// ============================================================================
-// BUILD & TEST
-// ============================================================================
-function runBuild(workingDir) {
-    try {
-        execSync('npm run build', { cwd: workingDir, encoding: 'utf-8', stdio: 'pipe' });
-        return { success: true };
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return { success: false, error: msg.slice(0, 500) };
-    }
-}
-function runTests(workingDir) {
-    try {
-        execSync('npm test', { cwd: workingDir, encoding: 'utf-8', stdio: 'pipe', timeout: 120000 });
-        return { success: true };
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return { success: false, error: msg.slice(0, 500) };
-    }
-}
-// ============================================================================
-// RELAUNCH
-// ============================================================================
-/**
- * Relaunch erosolar-cli with the new code
- */
-export function relaunchWithNewCode(workingDir) {
-    log('Relaunching with new code...');
-    // Increment relaunch count
-    evolutionState.relaunchCount++;
-    saveState();
-    // Spawn new process
-    const args = process.argv.slice(2);
-    args.push('--continue-evolution'); // Flag to continue evolution
-    spawn('node', ['dist/bin/erosolar.js', ...args], {
-        cwd: workingDir,
-        stdio: 'inherit',
-        detached: false,
-    });
-    // Exit current process
-    process.exit(0);
+export function analyzeSource(_path) {
+    return [];
 }
-/**
- * Run the full self-evolution loop
- */
-export async function runSelfEvolution(workingDir, config = {}, callbacks = {}) {
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-    // Verify we're in erosolar repo
-    if (!isErosolarRepo(workingDir)) {
-        return {
-            success: false,
-            iteration: 0,
-            issuesFound: 0,
-            issuesFixed: 0,
-            filesChanged: [],
-            nextAction: 'done',
-            error: 'Not in erosolar-cli repository',
-        };
-    }
-    // Load or initialize state
-    evolutionState = loadState();
-    // Check if this is a continuation
-    const isContinuation = process.argv.includes('--continue-evolution');
-    if (!isContinuation) {
-        // Fresh start - create checkpoint
-        evolutionState = {
-            isRunning: true,
-            startTime: new Date().toISOString(),
-            iteration: 0,
-            totalFixed: 0,
-            totalFailed: 0,
-            checkpointTag: createCheckpoint(workingDir),
-            lastCommit: null,
-            relaunchCount: 0,
-        };
-        saveState();
-        log(`Started self-evolution. Checkpoint: ${evolutionState.checkpointTag}`);
-    }
-    else {
-        evolutionState.isRunning = true;
-        log(`Continuing self-evolution. Iteration: ${evolutionState.iteration}, Relaunch: ${evolutionState.relaunchCount}`);
-    }
-    callbacks.onStart?.();
-    try {
-        while (evolutionState.isRunning && evolutionState.iteration < cfg.maxIterations) {
-            evolutionState.iteration++;
-            saveState();
-            log(`=== Iteration ${evolutionState.iteration} ===`);
-            // Analyze source
-            const issues = analyzeSource(workingDir);
-            const highConfidence = issues.filter(i => i.confidence >= cfg.minConfidence);
-            callbacks.onIteration?.(evolutionState.iteration, highConfidence);
-            if (highConfidence.length === 0) {
-                log('No high-confidence issues found. Evolution complete.');
-                return {
-                    success: true,
-                    iteration: evolutionState.iteration,
-                    issuesFound: issues.length,
-                    issuesFixed: evolutionState.totalFixed,
-                    filesChanged: [],
-                    nextAction: 'done',
-                };
-            }
-            log(`Found ${highConfidence.length} high-confidence issues`);
-            // Take the highest priority issue
-            const issue = highConfidence[0];
-            log(`Attempting to fix: ${issue.file}:${issue.line} - ${issue.description}`);
-            // For now, we can only fix issues we have automated fixes for
-            // In a full implementation, we would use the LLM to generate fixes
-            // Validate current state
-            const buildResult = runBuild(workingDir);
-            if (!buildResult.success) {
-                log(`Build failed: ${buildResult.error}`);
-                evolutionState.totalFailed++;
-                callbacks.onFix?.(issue, false);
-                // Rollback if we made changes
-                if (evolutionState.checkpointTag) {
-                    rollbackToCheckpoint(workingDir, evolutionState.checkpointTag);
-                    evolutionState.checkpointTag = createCheckpoint(workingDir);
-                }
-                continue;
-            }
-            if (cfg.runTests) {
-                const testResult = runTests(workingDir);
-                if (!testResult.success) {
-                    log(`Tests failed: ${testResult.error}`);
-                    evolutionState.totalFailed++;
-                    callbacks.onFix?.(issue, false);
-                    continue;
-                }
-            }
-            // If we get here with no actual fixes applied, continue to next iteration
-            // In a full implementation, we would have applied a fix
-            // Simulate some delay
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            // Check if we should relaunch (every 10 successful fixes)
-            if (cfg.autoRelaunch && evolutionState.totalFixed > 0 && evolutionState.totalFixed % 10 === 0) {
-                callbacks.onRelaunch?.();
-                relaunchWithNewCode(workingDir);
-                return {
-                    success: true,
-                    iteration: evolutionState.iteration,
-                    issuesFound: issues.length,
-                    issuesFixed: evolutionState.totalFixed,
-                    filesChanged: [],
-                    nextAction: 'relaunch',
-                };
-            }
-        }
-        // Reached max iterations
-        return {
-            success: true,
-            iteration: evolutionState.iteration,
-            issuesFound: 0,
-            issuesFixed: evolutionState.totalFixed,
-            filesChanged: [],
-            nextAction: 'done',
-        };
-    }
-    catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        log(`Evolution error: ${errorMsg}`);
-        callbacks.onError?.(errorMsg);
-        // Rollback on error
-        if (evolutionState.checkpointTag) {
-            rollbackToCheckpoint(workingDir, evolutionState.checkpointTag);
-        }
-        return {
-            success: false,
-            iteration: evolutionState.iteration,
-            issuesFound: 0,
-            issuesFixed: evolutionState.totalFixed,
-            filesChanged: [],
-            nextAction: 'rollback',
-            error: errorMsg,
-        };
-    }
-    finally {
-        evolutionState.isRunning = false;
-        saveState();
-    }
+export async function runSelfEvolution(_sourcePath, _options, _callbacks) {
+    return {
+        success: false,
+        iteration: 0,
+        issuesFound: 0,
+        issuesFixed: 0,
+        error: 'Feature deprecated',
+        nextAction: 'none',
+    };
 }
-/**
- * Stop the evolution process
- */
 export function stopEvolution() {
-    evolutionState.isRunning = false;
-    saveState();
-    log('Evolution stopped by user');
-}
-/**
- * Get current evolution state
- */
-export function getEvolutionState() {
-    return { ...loadState() };
-}
-/**
- * Emergency rollback to last checkpoint
- */
-export function emergencyEvolutionRollback(workingDir) {
-    const state = loadState();
-    if (!state.checkpointTag) {
-        return { success: false, message: 'No checkpoint found' };
-    }
-    const success = rollbackToCheckpoint(workingDir, state.checkpointTag);
-    if (success) {
-        // Reset state
-        evolutionState = {
-            isRunning: false,
-            startTime: null,
-            iteration: 0,
-            totalFixed: 0,
-            totalFailed: 0,
-            checkpointTag: null,
-            lastCommit: null,
-            relaunchCount: 0,
-        };
-        saveState();
-        return { success: true, message: `Rolled back to ${state.checkpointTag}` };
-    }
-    return { success: false, message: 'Rollback failed' };
-}
-/**
- * Get formatted status for display
- */
-export function getEvolutionStatus(workingDir) {
-    const state = loadState();
-    const version = getVersion(workingDir);
-    const isValid = isValidSourceRepo(workingDir);
-    const repoName = getRepoName(workingDir);
-    const isErosolar = isErosolarRepo(workingDir);
-    const lines = [];
-    lines.push('═══════════════════════════════════════════════════════════');
-    lines.push('     🧬 Self-Evolution System');
-    lines.push('═══════════════════════════════════════════════════════════');
-    lines.push('');
-    lines.push(`Repository: ${isValid ? `✅ ${repoName}` : '❌ Not a valid source repo'}`);
-    if (isErosolar) {
-        lines.push(`Type: erosolar-cli (enhanced self-improvement)`);
-    }
-    lines.push(`Version: ${version}`);
-    lines.push('');
-    if (state.isRunning) {
-        lines.push('Status: 🔄 RUNNING');
-        lines.push(`  Started: ${state.startTime}`);
-        lines.push(`  Iteration: ${state.iteration}`);
-        lines.push(`  Fixed: ${state.totalFixed}`);
-        lines.push(`  Failed: ${state.totalFailed}`);
-        lines.push(`  Relaunches: ${state.relaunchCount}`);
-    }
-    else if (state.totalFixed > 0 || state.totalFailed > 0) {
-        lines.push('Status: ⏸️ PAUSED');
-        lines.push(`  Last run: ${state.startTime}`);
-        lines.push(`  Total fixed: ${state.totalFixed}`);
-        lines.push(`  Total failed: ${state.totalFailed}`);
-    }
-    else {
-        lines.push('Status: ⏹️ NOT STARTED');
-    }
-    lines.push('');
-    lines.push('Commands:');
-    lines.push('  /evolve start    - Start self-evolution loop');
-    lines.push('  /evolve stop     - Stop evolution');
-    lines.push('  /evolve status   - Show this status');
-    lines.push('  /evolve rollback - Emergency rollback');
-    lines.push('  /evolve analyze  - Analyze source without fixing');
-    lines.push('  /evolve learn    - Learn patterns from source code');
-    lines.push('  /evolve fix      - Generate fix suggestions');
-    lines.push('');
-    lines.push('═══════════════════════════════════════════════════════════');
-    return lines.join('\n');
-}
-const LEARNED_PATTERNS_FILE = join(homedir(), '.erosolar', 'source-patterns.json');
-/**
- * Learn optimal patterns from erosolar-cli's own source code
- */
-export function learnSourcePatterns(workingDir) {
-    const patterns = [];
-    const srcDir = join(workingDir, 'src');
-    if (!existsSync(srcDir)) {
-        return patterns;
-    }
-    const tsFiles = findFiles(srcDir, '.ts');
-    for (const file of tsFiles) {
-        const content = readFileSync(file, 'utf-8');
-        const relativePath = relative(workingDir, file);
-        // Learn tool implementation patterns from tools/ directory
-        if (relativePath.includes('/tools/')) {
-            const toolPatterns = extractToolPatterns(content, relativePath);
-            patterns.push(...toolPatterns);
-        }
-        // Learn error handling patterns
-        const errorPatterns = extractErrorHandlingPatterns(content, relativePath);
-        patterns.push(...errorPatterns);
-        // Learn type patterns from well-typed code
-        const typePatterns = extractTypePatterns(content, relativePath);
-        patterns.push(...typePatterns);
-        // Learn API design patterns from core modules
-        if (relativePath.includes('/core/') || relativePath.includes('/providers/')) {
-            const apiPatterns = extractApiPatterns(content, relativePath);
-            patterns.push(...apiPatterns);
-        }
-    }
-    // Deduplicate and rank by confidence
-    const uniquePatterns = deduplicatePatterns(patterns);
-    // Save learned patterns
-    saveLearnedPatterns(uniquePatterns);
-    return uniquePatterns;
-}
-function extractToolPatterns(content, sourceFile) {
-    const patterns = [];
-    // Extract tool definition patterns
-    const toolDefMatch = content.match(/export\s+(?:const|function)\s+(\w+Tool)\s*[=:]/);
-    if (toolDefMatch) {
-        patterns.push({
-            category: 'tool-implementation',
-            description: 'Tool export pattern using named function/const',
-            example: toolDefMatch[0],
-            sourceFile,
-            confidence: 0.9,
-            usageCount: 1,
-        });
-    }
-    // Extract schema validation patterns
-    const schemaMatch = content.match(/inputSchema:\s*\{[\s\S]*?type:\s*['"]object['"]/);
-    if (schemaMatch) {
-        patterns.push({
-            category: 'tool-implementation',
-            description: 'Tool input schema with JSON Schema validation',
-            example: schemaMatch[0].slice(0, 200),
-            sourceFile,
-            confidence: 0.95,
-            usageCount: 1,
-        });
-    }
-    // Extract handler patterns
-    const handlerMatch = content.match(/handler:\s*async\s*\([\s\S]*?\)\s*=>\s*\{/);
-    if (handlerMatch) {
-        patterns.push({
-            category: 'tool-implementation',
-            description: 'Async tool handler pattern',
-            example: handlerMatch[0],
-            sourceFile,
-            confidence: 0.9,
-            usageCount: 1,
-        });
-    }
-    return patterns;
-}
-function extractErrorHandlingPatterns(content, sourceFile) {
-    const patterns = [];
-    // Good: Typed catch blocks
-    const typedCatch = content.match(/catch\s*\(\s*(\w+)\s*\)\s*\{[\s\S]*?instanceof\s+Error/g);
-    if (typedCatch && typedCatch.length > 0) {
-        patterns.push({
-            category: 'error-handling',
-            description: 'Typed error handling with instanceof check',
-            example: typedCatch[0].slice(0, 150),
-            sourceFile,
-            confidence: 0.85,
-            usageCount: typedCatch.length,
-        });
-    }
-    // Good: Result type patterns
-    const resultPattern = content.match(/:\s*\{\s*success:\s*boolean[;,]\s*(?:error|message|data)/);
-    if (resultPattern) {
-        patterns.push({
-            category: 'error-handling',
-            description: 'Result object pattern { success, error/data }',
-            example: resultPattern[0],
-            sourceFile,
-            confidence: 0.9,
-            usageCount: 1,
-        });
-    }
-    return patterns;
+    // No-op stub
 }
-function extractTypePatterns(content, sourceFile) {
-    const patterns = [];
-    // Interface definitions
-    const interfaces = content.match(/export\s+interface\s+\w+\s*\{[^}]+\}/g);
-    if (interfaces && interfaces.length > 0) {
-        for (const iface of interfaces.slice(0, 3)) {
-            patterns.push({
-                category: 'type-pattern',
-                description: 'Exported interface definition',
-                example: iface.slice(0, 200),
-                sourceFile,
-                confidence: 0.8,
-                usageCount: 1,
-            });
-        }
-    }
-    // Type guards
-    const typeGuards = content.match(/function\s+is\w+\s*\([^)]+\):\s*\w+\s+is\s+\w+/g);
-    if (typeGuards && typeGuards.length > 0) {
-        patterns.push({
-            category: 'type-pattern',
-            description: 'Type guard function pattern',
-            example: typeGuards[0],
-            sourceFile,
-            confidence: 0.95,
-            usageCount: typeGuards.length,
-        });
-    }
-    return patterns;
+export function getEvolutionStatus(_workingDir) {
+    return 'Evolution feature is deprecated';
 }
-function extractApiPatterns(content, sourceFile) {
-    const patterns = [];
-    // Factory functions
-    const factory = content.match(/export\s+(?:async\s+)?function\s+create\w+\s*\(/);
-    if (factory) {
-        patterns.push({
-            category: 'api-design',
-            description: 'Factory function pattern (createX)',
-            example: factory[0],
-            sourceFile,
-            confidence: 0.85,
-            usageCount: 1,
-        });
-    }
-    // Builder patterns
-    const builder = content.match(/export\s+(?:async\s+)?function\s+build\w+\s*\(/);
-    if (builder) {
-        patterns.push({
-            category: 'api-design',
-            description: 'Builder function pattern (buildX)',
-            example: builder[0],
-            sourceFile,
-            confidence: 0.85,
-            usageCount: 1,
-        });
-    }
-    return patterns;
+export function emergencyEvolutionRollback(_workingDir) {
+    return { success: true, message: 'No rollback needed (feature deprecated)' };
 }
-function deduplicatePatterns(patterns) {
-    const seen = new Map();
-    for (const pattern of patterns) {
-        const key = `${pattern.category}:${pattern.description}`;
-        const existing = seen.get(key);
-        if (existing) {
-            existing.usageCount += pattern.usageCount;
-            existing.confidence = Math.max(existing.confidence, pattern.confidence);
-        }
-        else {
-            seen.set(key, { ...pattern });
-        }
-    }
-    return Array.from(seen.values())
-        .sort((a, b) => b.confidence - a.confidence);
-}
-function saveLearnedPatterns(patterns) {
-    const dir = join(homedir(), '.erosolar');
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(LEARNED_PATTERNS_FILE, JSON.stringify(patterns, null, 2));
-}
-/**
- * Get all learned patterns
- */
-export function getLearnedPatterns() {
-    try {
-        if (existsSync(LEARNED_PATTERNS_FILE)) {
-            return JSON.parse(readFileSync(LEARNED_PATTERNS_FILE, 'utf-8'));
-        }
-    }
-    catch {
-        // Ignore
-    }
+export function learnSourcePatterns(_path) {
     return [];
 }
-/**
- * Generate a fix for a source issue using learned patterns
- * Note: This uses pattern matching; full LLM integration requires runtime context
- */
-export function generateFix(issue, workingDir) {
-    const filePath = join(workingDir, issue.file);
-    if (!existsSync(filePath)) {
-        return null;
-    }
-    const content = readFileSync(filePath, 'utf-8');
-    const lines = content.split('\n');
-    // Get the problematic line
-    const lineIndex = (issue.line ?? 1) - 1;
-    if (lineIndex < 0 || lineIndex >= lines.length) {
-        return null;
-    }
-    const problemLine = lines[lineIndex];
-    // Apply pattern-based fixes
-    let suggestedCode = null;
-    let explanation = '';
-    let confidence = 0.5;
-    let requiresManualReview = true;
-    // Fix: as any -> add proper type annotation
-    if (issue.description.includes('as any')) {
-        const match = problemLine.match(/(\w+)\s+as\s+any/);
-        if (match) {
-            suggestedCode = problemLine.replace(/as\s+any/, `as unknown /* TODO: add proper type */`);
-            explanation = 'Replace "as any" with "as unknown" as a safer intermediate step. Add proper type annotation.';
-            confidence = 0.7;
-        }
-    }
-    // Fix: empty catch blocks -> add error handling
-    if (issue.description.includes('catch') && issue.description.includes('empty')) {
-        suggestedCode = problemLine.replace(/catch\s*\(\s*\)\s*\{/, 'catch (error) {\n    // Log error for debugging\n    console.error(error);');
-        explanation = 'Added error parameter and logging to empty catch block.';
-        confidence = 0.8;
-    }
-    // Fix: @ts-ignore -> @ts-expect-error with reason
-    if (issue.description.includes('@ts-ignore')) {
-        suggestedCode = problemLine.replace(/\/\/\s*@ts-ignore.*/, '// @ts-expect-error - TODO: fix underlying type issue');
-        explanation = 'Replace @ts-ignore with @ts-expect-error which is preferred for intentional suppressions.';
-        confidence = 0.85;
-    }
-    // Fix: forEach -> for...of for better performance
-    if (issue.description.includes('forEach')) {
-        const match = problemLine.match(/(\w+)\.forEach\s*\(\s*(?:\(([^)]+)\)|(\w+))\s*=>/);
-        if (match) {
-            const arr = match[1];
-            // Can't auto-fix reliably without understanding the full block
-            explanation = `Consider replacing ${arr}.forEach with for...of loop for better performance and break/continue support.`;
-            confidence = 0.4;
-            requiresManualReview = true;
-        }
-    }
-    if (!suggestedCode) {
-        return null;
-    }
-    return {
-        issue,
-        suggestedCode,
-        explanation,
-        confidence,
-        requiresManualReview,
-    };
-}
-/**
- * Apply a fix to the source file
- */
-export function applyFix(fix, workingDir) {
-    const filePath = join(workingDir, fix.issue.file);
-    if (!existsSync(filePath)) {
-        return false;
-    }
-    try {
-        const content = readFileSync(filePath, 'utf-8');
-        const lines = content.split('\n');
-        const lineIndex = (fix.issue.line ?? 1) - 1;
-        if (lineIndex < 0 || lineIndex >= lines.length) {
-            return false;
-        }
-        // Replace the line
-        lines[lineIndex] = fix.suggestedCode;
-        writeFileSync(filePath, lines.join('\n'));
-        log(`Applied fix to ${fix.issue.file}:${fix.issue.line}`);
-        return true;
-    }
-    catch (error) {
-        log(`Failed to apply fix: ${error instanceof Error ? error.message : String(error)}`);
-        return false;
-    }
-}
-/**
- * Get a summary of what can be learned from the source code
- */
-export function getSourceLearningSummary(workingDir) {
-    const patterns = learnSourcePatterns(workingDir);
-    const existingPatterns = getLearnedPatterns();
-    const lines = [];
-    lines.push('═══════════════════════════════════════════════════════════');
-    lines.push('     📚 Source Code Learning Summary');
-    lines.push('═══════════════════════════════════════════════════════════');
-    lines.push('');
-    const byCategory = {
-        'tool-implementation': patterns.filter(p => p.category === 'tool-implementation'),
-        'error-handling': patterns.filter(p => p.category === 'error-handling'),
-        'type-pattern': patterns.filter(p => p.category === 'type-pattern'),
-        'api-design': patterns.filter(p => p.category === 'api-design'),
-        'performance': patterns.filter(p => p.category === 'performance'),
-    };
-    lines.push(`Total patterns learned: ${patterns.length}`);
-    lines.push(`Previously learned: ${existingPatterns.length}`);
-    lines.push('');
-    lines.push('By Category:');
-    for (const [category, catPatterns] of Object.entries(byCategory)) {
-        if (catPatterns.length > 0) {
-            const icon = category === 'tool-implementation' ? '🔧' :
-                category === 'error-handling' ? '⚠️' :
-                    category === 'type-pattern' ? '📝' :
-                        category === 'api-design' ? '🏗️' : '⚡';
-            lines.push(`  ${icon} ${category}: ${catPatterns.length}`);
-        }
-    }
-    lines.push('');
-    lines.push('Top Patterns (by confidence):');
-    for (const pattern of patterns.slice(0, 5)) {
-        lines.push(`  • ${pattern.description}`);
-        lines.push(`    Source: ${pattern.sourceFile}`);
-        lines.push(`    Confidence: ${Math.round(pattern.confidence * 100)}%`);
-    }
-    lines.push('');
-    lines.push('═══════════════════════════════════════════════════════════');
-    return lines.join('\n');
+export function generateFix(_issue, _workingDirOrContext) {
+    return null;
 }
 //# sourceMappingURL=selfEvolution.js.map