erosolar-cli 1.7.284 → 1.7.285

package/dist/core/aiFlowOptimizer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Lightweight AI flow optimizer stub.
+ */
+export interface AIFlowMetrics {
+    latencyMs: number;
+    toolCalls: number;
+    tokenUsage?: number;
+    parallelExecution?: boolean;
+}
+export interface OptimizedFlow {
+    originalMetrics: AIFlowMetrics;
+    optimizedMetrics: AIFlowMetrics;
+    suggestions: string[];
+}
+export interface OptimizationInsights {
+    patterns: string[];
+    averageLatency?: number;
+}
+export declare class AIFlowOptimizer {
+    constructor(_options?: {
+        workingDir?: string;
+    });
+    analyzeFlow(flowData: any): OptimizedFlow;
+    getOptimizationInsights(): OptimizationInsights;
+}
+//# sourceMappingURL=aiFlowOptimizer.d.ts.map

package/dist/core/aiFlowOptimizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiFlowOptimizer.d.ts","sourceRoot":"","sources":["../../src/core/aiFlowOptimizer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B,eAAe,EAAE,aAAa,CAAC;IAC/B,gBAAgB,EAAE,aAAa,CAAC;IAChC,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,eAAe;gBAEd,QAAQ,GAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO;IAElD,WAAW,CAAC,QAAQ,EAAE,GAAG,GAAG,aAAa;IAoBzC,uBAAuB,IAAI,oBAAoB;CAMhD"}

package/dist/core/aiFlowOptimizer.js

@@ -0,0 +1,31 @@
+/**
+ * Lightweight AI flow optimizer stub.
+ */
+export class AIFlowOptimizer {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(_options = {}) { }
+    analyzeFlow(flowData) {
+        const baseline = {
+            latencyMs: Number(flowData?.latencyMs ?? 1000),
+            toolCalls: Number(flowData?.toolCalls ?? 1),
+            tokenUsage: Number(flowData?.tokenUsage ?? 0),
+            parallelExecution: Boolean(flowData?.parallelExecution ?? false),
+        };
+        const optimized = {
+            ...baseline,
+            latencyMs: Math.max(100, Math.round(baseline.latencyMs * 0.9)),
+        };
+        return {
+            originalMetrics: baseline,
+            optimizedMetrics: optimized,
+            suggestions: ['Enable parallel execution where safe', 'Trim redundant tool calls'],
+        };
+    }
+    getOptimizationInsights() {
+        return {
+            patterns: ['stub-optimization-pattern'],
+            averageLatency: undefined,
+        };
+    }
+}
+//# sourceMappingURL=aiFlowOptimizer.js.map

package/dist/core/aiFlowOptimizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiFlowOptimizer.js","sourceRoot":"","sources":["../../src/core/aiFlowOptimizer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAoBH,MAAM,OAAO,eAAe;IAC1B,6DAA6D;IAC7D,YAAY,WAAoC,EAAE,IAAG,CAAC;IAEtD,WAAW,CAAC,QAAa;QACvB,MAAM,QAAQ,GAAkB;YAC9B,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,SAAS,IAAI,IAAI,CAAC;YAC9C,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,SAAS,IAAI,CAAC,CAAC;YAC3C,UAAU,EAAE,MAAM,CAAC,QAAQ,EAAE,UAAU,IAAI,CAAC,CAAC;YAC7C,iBAAiB,EAAE,OAAO,CAAC,QAAQ,EAAE,iBAAiB,IAAI,KAAK,CAAC;SACjE,CAAC;QAEF,MAAM,SAAS,GAAkB;YAC/B,GAAG,QAAQ;YACX,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC;SAC/D,CAAC;QAEF,OAAO;YACL,eAAe,EAAE,QAAQ;YACzB,gBAAgB,EAAE,SAAS;YAC3B,WAAW,EAAE,CAAC,sCAAsC,EAAE,2BAA2B,CAAC;SACnF,CAAC;IACJ,CAAC;IAED,uBAAuB;QACrB,OAAO;YACL,QAAQ,EAAE,CAAC,2BAA2B,CAAC;YACvC,cAAc,EAAE,SAAS;SAC1B,CAAC;IACJ,CAAC;CACF"}

package/dist/core/aiOptimizationEngine.d.ts

@@ -0,0 +1,158 @@
+/**
+ * AI Optimization Engine - Advanced Decision Making and Error Recovery
+ *
+ * Provides intelligent problem-solving with:
+ * - Optimal solution path analysis
+ * - Multi-strategy decision making
+ * - Intelligent error recovery
+ * - Performance optimization
+ * - Context-aware reasoning
+ *
+ * @license MIT
+ * @author Bo Shang
+ */
+export declare enum ProblemComplexity {
+    TRIVIAL = "trivial",// Single-step, deterministic solution
+    SIMPLE = "simple",// 2-3 steps, clear path
+    MODERATE = "moderate",// Multiple steps, some uncertainty
+    COMPLEX = "complex",// Complex dependencies, multiple approaches
+    VERY_COMPLEX = "very_complex"
+}
+export declare enum SolutionStrategy {
+    DIRECT = "direct",// Straightforward implementation
+    INCREMENTAL = "incremental",// Step-by-step with validation
+    DEFENSIVE = "defensive",// Conservative with fallbacks
+    OPTIMISTIC = "optimistic",// Aggressive with rollback
+    ADAPTIVE = "adaptive",// Dynamic strategy selection
+    EXPLORATORY = "exploratory"
+}
+export interface ProblemAnalysis {
+    complexity: ProblemComplexity;
+    riskLevel: 'low' | 'medium' | 'high';
+    dependencies: string[];
+    constraints: string[];
+    successCriteria: string[];
+    failurePoints: string[];
+    optimalStrategy: SolutionStrategy;
+    alternativeStrategies: SolutionStrategy[];
+    estimatedSteps: number;
+    confidence: number;
+}
+export interface SolutionPath {
+    strategy: SolutionStrategy;
+    steps: SolutionStep[];
+    validationPoints: ValidationPoint[];
+    rollbackPlan: RollbackStep[];
+    estimatedTime: number;
+    successProbability: number;
+}
+export interface SolutionStep {
+    id: string;
+    action: string;
+    tool?: string;
+    parameters?: Record<string, unknown>;
+    validation?: string;
+    fallback?: string;
+}
+export interface ValidationPoint {
+    stepId: string;
+    validationType: 'tool_output' | 'file_content' | 'test_result' | 'user_confirmation';
+    expectedPattern?: string;
+    failureAction: 'retry' | 'fallback' | 'abort';
+}
+export interface RollbackStep {
+    stepId: string;
+    action: string;
+    tool?: string;
+    parameters?: Record<string, unknown>;
+}
+export interface ErrorRecoveryStrategy {
+    errorType: string;
+    errorPattern: RegExp;
+    recoveryActions: RecoveryAction[];
+    priority: 'immediate' | 'high' | 'medium' | 'low';
+    autoRecoverable: boolean;
+}
+export interface RecoveryAction {
+    action: string;
+    tool?: string;
+    parameters?: Record<string, unknown>;
+    validation?: string;
+    successProbability: number;
+}
+export declare class AIOptimizationEngine {
+    private readonly workingDir;
+    private readonly performanceThresholds;
+    constructor(options?: {
+        workingDir?: string;
+    });
+    /**
+     * Analyze problem and determine optimal solution strategy
+     */
+    analyzeProblem(problemDescription: string, context?: {
+        filesRead?: string[];
+        toolsUsed?: string[];
+        errorsEncountered?: string[];
+        complexityHints?: string[];
+    }): ProblemAnalysis;
+    /**
+     * Generate optimal solution path with validation and rollback
+     */
+    generateSolutionPath(analysis: ProblemAnalysis, context: {
+        availableTools: string[];
+        currentState: Record<string, unknown>;
+        userPreferences?: {
+            riskTolerance: 'low' | 'medium' | 'high';
+            validationPreference: 'minimal' | 'balanced' | 'thorough';
+        };
+    }): SolutionPath;
+    /**
+     * Intelligent error recovery with multiple strategies
+     */
+    recoverFromError(error: string, context: {
+        currentStep: SolutionStep;
+        analysis: ProblemAnalysis;
+        attemptedSolutions: string[];
+        availableTools: string[];
+    }): RecoveryAction[];
+    /**
+     * Optimize AI flow for efficiency and effectiveness
+     */
+    optimizeAIFlow(currentFlow: {
+        toolCalls: Array<{
+            tool: string;
+            parameters: Record<string, unknown>;
+        }>;
+        contextUsage: {
+            filesRead: number;
+            searches: number;
+            edits: number;
+        };
+        validationRounds: number;
+    }): {
+        optimizedFlow: Array<{
+            tool: string;
+            parameters: Record<string, unknown>;
+        }>;
+        efficiencyGains: number;
+        recommendations: string[];
+    };
+    private assessComplexity;
+    private assessRisk;
+    private extractDependencies;
+    private extractConstraints;
+    private extractSuccessCriteria;
+    private identifyFailurePoints;
+    private selectOptimalStrategy;
+    private getAlternativeStrategies;
+    private estimateSteps;
+    private calculateConfidence;
+    private generateSteps;
+    private getErrorRecoveryStrategies;
+    private isStrategyApplicable;
+    private detectSequentialReads;
+    private mergeSequentialReads;
+    private calculateContextEfficiency;
+    private calculateEfficiencyGains;
+}
+//# sourceMappingURL=aiOptimizationEngine.d.ts.map

package/dist/core/aiOptimizationEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiOptimizationEngine.d.ts","sourceRoot":"","sources":["../../src/core/aiOptimizationEngine.ts"],"names":[],"mappings":"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"}

package/dist/core/aiOptimizationEngine.js

@@ -0,0 +1,428 @@
+/**
+ * AI Optimization Engine - Advanced Decision Making and Error Recovery
+ *
+ * Provides intelligent problem-solving with:
+ * - Optimal solution path analysis
+ * - Multi-strategy decision making
+ * - Intelligent error recovery
+ * - Performance optimization
+ * - Context-aware reasoning
+ *
+ * @license MIT
+ * @author Bo Shang
+ */
+export var ProblemComplexity;
+(function (ProblemComplexity) {
+    ProblemComplexity["TRIVIAL"] = "trivial";
+    ProblemComplexity["SIMPLE"] = "simple";
+    ProblemComplexity["MODERATE"] = "moderate";
+    ProblemComplexity["COMPLEX"] = "complex";
+    ProblemComplexity["VERY_COMPLEX"] = "very_complex"; // High uncertainty, multiple failure points
+})(ProblemComplexity || (ProblemComplexity = {}));
+export var SolutionStrategy;
+(function (SolutionStrategy) {
+    SolutionStrategy["DIRECT"] = "direct";
+    SolutionStrategy["INCREMENTAL"] = "incremental";
+    SolutionStrategy["DEFENSIVE"] = "defensive";
+    SolutionStrategy["OPTIMISTIC"] = "optimistic";
+    SolutionStrategy["ADAPTIVE"] = "adaptive";
+    SolutionStrategy["EXPLORATORY"] = "exploratory"; // Test multiple approaches
+})(SolutionStrategy || (SolutionStrategy = {}));
+export class AIOptimizationEngine {
+    workingDir;
+    performanceThresholds = {
+        maxSequentialReads: 3,
+        maxValidationRounds: 2,
+        maxRetryAttempts: 3,
+        contextEfficiencyThreshold: 0.7 // 70% context utilization
+    };
+    constructor(options = {}) {
+        this.workingDir = options.workingDir ?? process.cwd();
+    }
+    /**
+     * Analyze problem and determine optimal solution strategy
+     */
+    analyzeProblem(problemDescription, context = {}) {
+        const complexity = this.assessComplexity(problemDescription, context);
+        const riskLevel = this.assessRisk(problemDescription, context);
+        const dependencies = this.extractDependencies(problemDescription, context);
+        const constraints = this.extractConstraints(problemDescription);
+        const successCriteria = this.extractSuccessCriteria(problemDescription);
+        const failurePoints = this.identifyFailurePoints(problemDescription, context);
+        const optimalStrategy = this.selectOptimalStrategy(complexity, riskLevel, context);
+        const alternativeStrategies = this.getAlternativeStrategies(optimalStrategy, complexity);
+        const estimatedSteps = this.estimateSteps(complexity, problemDescription);
+        const confidence = this.calculateConfidence(complexity, context);
+        return {
+            complexity,
+            riskLevel,
+            dependencies,
+            constraints,
+            successCriteria,
+            failurePoints,
+            optimalStrategy,
+            alternativeStrategies,
+            estimatedSteps,
+            confidence
+        };
+    }
+    /**
+     * Generate optimal solution path with validation and rollback
+     */
+    generateSolutionPath(analysis, context) {
+        const strategy = analysis.optimalStrategy;
+        const steps = this.generateSteps(analysis, context);
+        const validationPoints = this.generateValidationPoints(steps, context);
+        const rollbackPlan = this.generateRollbackPlan(steps, analysis);
+        const estimatedTime = this.estimateTime(steps, analysis);
+        const successProbability = this.calculateSuccessProbability(analysis, context);
+        return {
+            strategy,
+            steps,
+            validationPoints,
+            rollbackPlan,
+            estimatedTime,
+            successProbability
+        };
+    }
+    /**
+     * Intelligent error recovery with multiple strategies
+     */
+    recoverFromError(error, context) {
+        const recoveryStrategies = this.getErrorRecoveryStrategies(error);
+        const applicableStrategies = recoveryStrategies.filter(strategy => this.isStrategyApplicable(strategy, context));
+        // Sort by priority and success probability
+        return applicableStrategies
+            .flatMap(strategy => strategy.recoveryActions)
+            .sort((a, b) => b.successProbability - a.successProbability)
+            .slice(0, 3); // Return top 3 recovery actions
+    }
+    /**
+     * Optimize AI flow for efficiency and effectiveness
+     */
+    optimizeAIFlow(currentFlow) {
+        const recommendations = [];
+        const optimizedFlow = [...currentFlow.toolCalls];
+        // Optimize sequential reads
+        const sequentialReads = this.detectSequentialReads(currentFlow.toolCalls);
+        if (sequentialReads.length > this.performanceThresholds.maxSequentialReads) {
+            recommendations.push(`Merge ${sequentialReads.length} sequential read operations into parallel reads`);
+            optimizedFlow.splice(0, optimizedFlow.length, ...this.mergeSequentialReads(optimizedFlow));
+        }
+        // Optimize validation timing
+        if (currentFlow.validationRounds > this.performanceThresholds.maxValidationRounds) {
+            recommendations.push(`Reduce validation rounds from ${currentFlow.validationRounds} to 1 (deferred validation)`);
+        }
+        // Optimize context usage
+        const contextEfficiency = this.calculateContextEfficiency(currentFlow.contextUsage);
+        if (contextEfficiency < this.performanceThresholds.contextEfficiencyThreshold) {
+            recommendations.push(`Improve context efficiency (current: ${(contextEfficiency * 100).toFixed(1)}%, target: ${(this.performanceThresholds.contextEfficiencyThreshold * 100).toFixed(1)}%)`);
+        }
+        const efficiencyGains = this.calculateEfficiencyGains(currentFlow, optimizedFlow);
+        return {
+            optimizedFlow,
+            efficiencyGains,
+            recommendations
+        };
+    }
+    // Private implementation methods
+    assessComplexity(description, context) {
+        const complexityIndicators = {
+            trivial: ['typo', 'format', 'rename', 'simple'],
+            simple: ['update', 'modify', 'add', 'remove'],
+            moderate: ['refactor', 'implement', 'create', 'integration'],
+            complex: ['architecture', 'redesign', 'migration', 'complex'],
+            very_complex: ['rewrite', 'overhaul', 'fundamental', 'strategic']
+        };
+        const lowerDesc = description.toLowerCase();
+        for (const [level, indicators] of Object.entries(complexityIndicators)) {
+            if (indicators.some(indicator => lowerDesc.includes(indicator))) {
+                return level;
+            }
+        }
+        // Fallback based on context
+        if (context.errorsEncountered && context.errorsEncountered.length > 2) {
+            return ProblemComplexity.COMPLEX;
+        }
+        if (context.filesRead && context.filesRead.length > 5) {
+            return ProblemComplexity.MODERATE;
+        }
+        return ProblemComplexity.SIMPLE;
+    }
+    assessRisk(description, context) {
+        const highRiskTerms = ['delete', 'drop', 'remove', 'overwrite', 'force', 'irreversible'];
+        const mediumRiskTerms = ['modify', 'update', 'change', 'edit', 'refactor'];
+        const lowerDesc = description.toLowerCase();
+        if (highRiskTerms.some(term => lowerDesc.includes(term))) {
+            return 'high';
+        }
+        if (mediumRiskTerms.some(term => lowerDesc.includes(term))) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    extractDependencies(description, context) {
+        const dependencies = [];
+        // Extract file dependencies from description
+        const filePattern = /[\w\/.-]+\.(ts|js|tsx|jsx|json|md|txt)/gi;
+        const fileMatches = description.match(filePattern) || [];
+        dependencies.push(...fileMatches);
+        // Add context dependencies
+        if (context.filesRead) {
+            dependencies.push(...context.filesRead);
+        }
+        return [...new Set(dependencies)]; // Remove duplicates
+    }
+    extractConstraints(description) {
+        const constraints = [];
+        const constraintPatterns = [
+            /(?:must|should|need to|required to)\s+([^.!?]+)/gi,
+            /(?:cannot|should not|must not)\s+([^.!?]+)/gi,
+            /(?:constraint|limit|restriction)[^.!?]*/gi
+        ];
+        for (const pattern of constraintPatterns) {
+            const matches = description.match(pattern) || [];
+            constraints.push(...matches);
+        }
+        return constraints;
+    }
+    extractSuccessCriteria(description) {
+        const criteria = [];
+        const successPatterns = [
+            /(?:should|must)\s+(?:work|function|compile|pass|succeed)/gi,
+            /(?:expected|desired)\s+([^.!?]+)/gi,
+            /(?:goal|objective)\s+is\s+([^.!?]+)/gi
+        ];
+        for (const pattern of successPatterns) {
+            const matches = description.match(pattern) || [];
+            criteria.push(...matches);
+        }
+        return criteria.length > 0 ? criteria : ['Complete implementation successfully'];
+    }
+    identifyFailurePoints(description, context) {
+        const failurePoints = [];
+        // Common failure points
+        const commonFailures = [
+            'TypeScript compilation errors',
+            'Test failures',
+            'Missing dependencies',
+            'File not found errors',
+            'Permission issues'
+        ];
+        // Add context-specific failure points
+        if (context.errorsEncountered) {
+            failurePoints.push(...context.errorsEncountered);
+        }
+        // Add based on complexity
+        const complexity = this.assessComplexity(description, context);
+        if (complexity >= ProblemComplexity.COMPLEX) {
+            failurePoints.push('Complex integration issues');
+            failurePoints.push('Architecture conflicts');
+        }
+        return [...new Set([...commonFailures, ...failurePoints])];
+    }
+    selectOptimalStrategy(complexity, riskLevel, context) {
+        // Strategy selection matrix
+        const strategyMatrix = {
+            [ProblemComplexity.TRIVIAL]: {
+                low: SolutionStrategy.DIRECT,
+                medium: SolutionStrategy.DIRECT,
+                high: SolutionStrategy.DEFENSIVE
+            },
+            [ProblemComplexity.SIMPLE]: {
+                low: SolutionStrategy.DIRECT,
+                medium: SolutionStrategy.INCREMENTAL,
+                high: SolutionStrategy.DEFENSIVE
+            },
+            [ProblemComplexity.MODERATE]: {
+                low: SolutionStrategy.INCREMENTAL,
+                medium: SolutionStrategy.ADAPTIVE,
+                high: SolutionStrategy.DEFENSIVE
+            },
+            [ProblemComplexity.COMPLEX]: {
+                low: SolutionStrategy.ADAPTIVE,
+                medium: SolutionStrategy.EXPLORATORY,
+                high: SolutionStrategy.DEFENSIVE
+            },
+            [ProblemComplexity.VERY_COMPLEX]: {
+                low: SolutionStrategy.EXPLORATORY,
+                medium: SolutionStrategy.EXPLORATORY,
+                high: SolutionStrategy.DEFENSIVE
+            }
+        };
+        return strategyMatrix[complexity][riskLevel];
+    }
+    getAlternativeStrategies(optimal, complexity) {
+        const allStrategies = Object.values(SolutionStrategy);
+        return allStrategies.filter(strategy => strategy !== optimal).slice(0, 2);
+    }
+    estimateSteps(complexity, description) {
+        const baseSteps = {
+            [ProblemComplexity.TRIVIAL]: 1,
+            [ProblemComplexity.SIMPLE]: 2,
+            [ProblemComplexity.MODERATE]: 4,
+            [ProblemComplexity.COMPLEX]: 8,
+            [ProblemComplexity.VERY_COMPLEX]: 15
+        };
+        // Adjust based on description length (proxy for complexity)
+        const lengthFactor = Math.min(description.length / 100, 2); // Cap at 2x
+        return Math.ceil(baseSteps[complexity] * lengthFactor);
+    }
+    calculateConfidence(complexity, context) {
+        let confidence = 1.0;
+        // Reduce confidence based on complexity
+        const complexityPenalty = {
+            [ProblemComplexity.TRIVIAL]: 0.0,
+            [ProblemComplexity.SIMPLE]: 0.1,
+            [ProblemComplexity.MODERATE]: 0.3,
+            [ProblemComplexity.COMPLEX]: 0.5,
+            [ProblemComplexity.VERY_COMPLEX]: 0.7
+        };
+        confidence -= complexityPenalty[complexity];
+        // Reduce confidence based on previous errors
+        if (context.errorsEncountered && context.errorsEncountered.length > 0) {
+            confidence -= 0.2 * Math.min(context.errorsEncountered.length, 3);
+        }
+        return Math.max(0.1, confidence); // Minimum 10% confidence
+    }
+    generateSteps(n, analysis, n, context, n) {
+        n;
+        const steps = [];
+        n;
+        n; // Generic steps based on strategy\n    switch (analysis.optimalStrategy) {\n      case SolutionStrategy.DIRECT:\n        steps.push({\n          id: 'direct_implementation',\n          action: 'Implement solution directly',\n          tool: 'Edit',\n          validation: 'Verify implementation matches requirements'\n        });\n        break;\n        \n      case SolutionStrategy.INCREMENTAL:\n        steps.push(\n          {\n            id: 'analysis',\n            action: 'Analyze current state and requirements',\n            tool: 'read_files',\n            validation: 'Understand the problem context'\n          },\n          {\n            id: 'plan',\n            action: 'Create implementation plan',\n            validation: 'Plan covers all requirements'\n          },\n          {\n            id: 'implement',\n            action: 'Implement solution incrementally',\n            tool: 'Edit',\n            validation: 'Each step passes validation'\n          }\n        );\n        break;\n        \n      case SolutionStrategy.DEFENSIVE:\n        steps.push(\n          {\n            id: 'backup',\n            action: 'Create backup of current state',\n            tool: 'execute_bash',\n            parameters: { command: 'git status' },\n            validation: 'Backup created successfully'\n          },\n          {\n            id: 'validate_current',\n            action: 'Validate current state',\n            tool: 'validate_all_changes',\n            validation: 'Current state is stable'\n          },\n          {\n            id: 'implement_carefully',\n            action: 'Implement with validation at each step',\n            tool: 'Edit',\n            validation: 'Each edit passes validation'\n          }\n        );\n        break;\n    }\n\n    return steps;\n  }\n\n  private generateValidationPoints(\n    steps: SolutionStep[],\n    context: any\n  ): ValidationPoint[] {\n    const validationPoints: ValidationPoint[] = [];\n\n    for (const step of steps) {\n      if (step.validation) {\n        validationPoints.push({\n          stepId: step.id,\n          validationType: 'tool_output',\n          failureAction: 'retry',\n          expectedPattern: step.validation\n        });\n      }\n    }\n\n    return validationPoints;\n  }\n\n  private generateRollbackPlan(\n    steps: SolutionStep[],\n    analysis: ProblemAnalysis\n  ): RollbackStep[] {\n    const rollbackSteps: RollbackStep[] = [];\n\n    // Add git-based rollback for defensive strategies\n    if (analysis.optimalStrategy === SolutionStrategy.DEFENSIVE) {\n      rollbackSteps.push({\n        stepId: 'git_rollback',\n        action: 'Revert all changes using git',\n        tool: 'execute_bash',\n        parameters: { command: 'git reset --hard HEAD' }\n      });\n    }\n\n    return rollbackSteps;\n  }\n\n  private estimateTime(steps: SolutionStep[], analysis: ProblemAnalysis): number {\n    const baseTimePerStep = 30; // seconds\n    const complexityMultiplier: Record<ProblemComplexity, number> = {\n      [ProblemComplexity.TRIVIAL]: 0.5,\n      [ProblemComplexity.SIMPLE]: 1,\n      [ProblemComplexity.MODERATE]: 2,\n      [ProblemComplexity.COMPLEX]: 4,\n      [ProblemComplexity.VERY_COMPLEX]: 8\n    };\n\n    return Math.ceil(steps.length * baseTimePerStep * complexityMultiplier[analysis.complexity]);\n  }\n\n  private calculateSuccessProbability(\n    analysis: ProblemAnalysis,\n    context: any\n  ): number {
+        let probability = analysis.confidence;
+        // Adjust based on available tools
+        if (context.availableTools && context.availableTools.length > 10) {
+            probability += 0.1;
+        }
+        // Adjust based on user preferences
+        if (context.userPreferences?.validationPreference === 'thorough') {
+            probability += 0.1;
+        }
+        return Math.min(0.95, probability); // Cap at 95%
+    }
+    getErrorRecoveryStrategies(error) {
+        const strategies = [
+            {
+                errorType: 'TypeScript Compilation Error',
+                errorPattern: /TS\d+:.*error/,
+                recoveryActions: [
+                    {
+                        action: 'Run TypeScript type checking to get detailed errors',
+                        tool: 'validate_typescript',
+                        successProbability: 0.9
+                    },
+                    {
+                        action: 'Fix TypeScript errors using suggested fixes',
+                        tool: 'suggest_fixes',
+                        successProbability: 0.7
+                    }
+                ],
+                priority: 'high',
+                autoRecoverable: true
+            },
+            {
+                errorType: 'Test Failure',
+                errorPattern: /FAIL\s+.*test/i,
+                recoveryActions: [
+                    {
+                        action: 'Run tests to get detailed failure information',
+                        tool: 'run_tests',
+                        successProbability: 0.8
+                    },
+                    {
+                        action: 'Analyze test failures and fix implementation',
+                        tool: 'analyze_code_structure',
+                        successProbability: 0.6
+                    }
+                ],
+                priority: 'high',
+                autoRecoverable: false
+            },
+            {
+                errorType: 'File Not Found',
+                errorPattern: /(?:file not found|cannot find|ENOENT)/i,
+                recoveryActions: [
+                    {
+                        action: 'Search for similar files',
+                        tool: 'search_files',
+                        successProbability: 0.5
+                    },
+                    {
+                        action: 'List files in directory to understand structure',
+                        tool: 'list_files',
+                        successProbability: 0.8
+                    }
+                ],
+                priority: 'medium',
+                autoRecoverable: true
+            }
+        ];
+        return strategies.filter(strategy => strategy.errorPattern.test(error));
+    }
+    isStrategyApplicable(strategy, context) {
+        // Check if required tools are available
+        const requiredTools = strategy.recoveryActions
+            .map(action => action.tool)
+            .filter(Boolean);
+        return requiredTools.every(tool => context.availableTools?.includes(tool));
+    }
+    detectSequentialReads(toolCalls) {
+        const sequentialReadIndices = [];
+        let currentSequence = [];
+        for (let i = 0; i < toolCalls.length; i++) {
+            const call = toolCalls[i];
+            if (call.tool.includes('read') || call.tool.includes('search')) {
+                currentSequence.push(i);
+            }
+            else {
+                if (currentSequence.length > 1) {
+                    sequentialReadIndices.push(...currentSequence);
+                }
+                currentSequence = [];
+            }
+        }
+        if (currentSequence.length > 1) {
+            sequentialReadIndices.push(...currentSequence);
+        }
+        return sequentialReadIndices;
+    }
+    mergeSequentialReads(toolCalls) {
+        const optimizedCalls = [...toolCalls];
+        const sequentialIndices = this.detectSequentialReads(toolCalls);
+        // Remove sequential reads and replace with parallel reads
+        for (let i = sequentialIndices.length - 1; i >= 0; i--) {
+            const index = sequentialIndices[i];
+            optimizedCalls.splice(index, 1);
+        }
+        // Add parallel read at the beginning of sequences
+        if (sequentialIndices.length > 0) {
+            const firstIndex = Math.min(...sequentialIndices);
+            const readFiles = sequentialIndices.map(idx => toolCalls[idx].parameters?.path).filter(Boolean);
+            if (readFiles.length > 0) {
+                optimizedCalls.splice(firstIndex, 0, {
+                    tool: 'read_files',
+                    parameters: { paths: readFiles }
+                });
+            }
+        }
+        return optimizedCalls;
+    }
+    calculateContextEfficiency(contextUsage) {
+        const totalOperations = contextUsage.filesRead + contextUsage.searches + contextUsage.edits;
+        if (totalOperations === 0)
+            return 1.0;
+        // Efficiency formula: higher ratio of productive operations (edits) to exploratory operations
+        const productiveRatio = contextUsage.edits / totalOperations;
+        const searchEfficiency = 1 - (contextUsage.searches / (contextUsage.filesRead + 1));
+        return (productiveRatio + searchEfficiency) / 2;
+    }
+    calculateEfficiencyGains(currentFlow, optimizedFlow) {
+        const currentOps = currentFlow.toolCalls.length;
+        const optimizedOps = optimizedFlow.length;
+        if (currentOps === 0)
+            return 0;
+        return ((currentOps - optimizedOps) / currentOps) * 100;
+    }
+}
+//# sourceMappingURL=aiOptimizationEngine.js.map