codehere 0.2.2 → 0.3.0-rc.2

package/dist/application/agents/execution-agent.js

@@ -1,508 +0,0 @@
-/**
- * Application Agent: Execution Agent (Code Migration)
- * Specialized agent for performing mechanical changes across files
- *
- * Based on enterprise architecture: Separate Execution Agent
- * Role: Executes plans created by Planning Agent
- */
-import { GitTool } from '../../tools/git-tool.js';
-import { agentValidationHelper } from '../../infrastructure/validation/agent-validation-helper.js';
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-export class ExecutionAgent {
-    aiService;
-    toolExecutor;
-    cwd;
-    gitTool;
-    constructor(aiService, toolExecutor, cwd = process.cwd()) {
-        this.aiService = aiService;
-        this.toolExecutor = toolExecutor;
-        this.cwd = cwd;
-        this.gitTool = new GitTool(cwd);
-    }
-    /**
-     * Execute plan or specific sub-plan
-     */
-    async execute(request) {
-        const { plan, subPlanId, context = {} } = request;
-        // Start validation context
-        const codebaseInfo = findCodebaseRoot(this.cwd);
-        const validationContext = agentValidationHelper.startAgentOperation('execution-agent', 'execute', {
-            query: plan.goal,
-            codebaseId: codebaseInfo?.codebaseId,
-        });
-        // Track files changed, tool calls, and rollback info
-        const filesChanged = [];
-        const filesCreated = [];
-        const filesDeleted = [];
-        const toolCalls = [];
-        const rollbackOccurred = { value: false };
-        try {
-            const results = [];
-            const updatedSubPlans = [...plan.subPlans];
-            // If executing specific sub-plan, do that and return
-            if (subPlanId) {
-                const subPlan = updatedSubPlans.find(sp => sp.id === subPlanId);
-                if (!subPlan) {
-                    throw new Error(`Sub-plan ${subPlanId} not found`);
-                }
-                const result = await this.executeSubPlan(subPlan, plan, context, { filesChanged, filesCreated, filesDeleted, toolCalls, rollbackOccurred });
-                const index = updatedSubPlans.findIndex(sp => sp.id === subPlanId);
-                if (index >= 0) {
-                    updatedSubPlans[index] = {
-                        ...subPlan,
-                        status: result.success ? 'completed' : 'failed',
-                        result: result.result,
-                        error: result.error,
-                    };
-                }
-                results.push(result);
-            }
-            else {
-                // Iterative execution: Keep executing until all sub-plans are done
-                let hasProgress = true;
-                const maxIterations = 100; // Prevent infinite loops
-                let iteration = 0;
-                while (hasProgress && iteration < maxIterations) {
-                    iteration++;
-                    // Mark sub-plans with failed dependencies as failed
-                    this.markBlockedSubPlans(updatedSubPlans);
-                    // Get currently executable sub-plans (dependencies satisfied)
-                    const executableSubPlans = this.getExecutableSubPlans({
-                        ...plan,
-                        subPlans: updatedSubPlans,
-                    });
-                    if (executableSubPlans.length === 0) {
-                        // No more executable sub-plans
-                        hasProgress = false;
-                        break;
-                    }
-                    // Execute all executable sub-plans
-                    for (const subPlan of executableSubPlans) {
-                        const result = await this.executeSubPlan(subPlan, plan, context, { filesChanged, filesCreated, filesDeleted, toolCalls, rollbackOccurred });
-                        // Update sub-plan status
-                        const index = updatedSubPlans.findIndex(sp => sp.id === subPlan.id);
-                        if (index >= 0) {
-                            updatedSubPlans[index] = {
-                                ...subPlan,
-                                status: result.success ? 'completed' : 'failed',
-                                result: result.result,
-                                error: result.error,
-                            };
-                        }
-                        results.push(result);
-                        // Stop if critical sub-plan fails
-                        if (!result.success && subPlan.estimatedComplexity === 'high') {
-                            hasProgress = false;
-                            break;
-                        }
-                    }
-                }
-                if (iteration >= maxIterations) {
-                    console.warn('⚠️  Execution reached max iterations - some sub-plans may not have been executed');
-                }
-            }
-            // Update plan status
-            const completedCount = updatedSubPlans.filter(sp => sp.status === 'completed').length;
-            const planStatus = completedCount === updatedSubPlans.length
-                ? 'completed'
-                : updatedSubPlans.some(sp => sp.status === 'failed')
-                    ? 'failed'
-                    : 'active';
-            const updatedPlan = {
-                ...plan,
-                subPlans: updatedSubPlans,
-                status: planStatus,
-                lastUpdated: new Date(),
-            };
-            // If execution was successful, commit changes (optional - can be disabled)
-            if (planStatus === 'completed' && results.length > 0) {
-                await this.commitSuccessfulChanges(plan, results);
-            }
-            // Extract files from results
-            this.extractFilesFromResults(results, filesChanged, filesCreated, filesDeleted);
-            // Complete validation
-            const validationResult = await agentValidationHelper.completeAgentOperation(validationContext, {
-                plan: updatedPlan,
-                results,
-                overallSuccess: planStatus === 'completed',
-                completedSubPlans: completedCount,
-                totalSubPlans: updatedSubPlans.length,
-            }, {
-                outcome: planStatus === 'completed' ? 'success' :
-                    planStatus === 'failed' ? 'failure' : 'partial_success',
-                filesChanged: Array.from(new Set(filesChanged)),
-                filesCreated: Array.from(new Set(filesCreated)),
-                filesDeleted: Array.from(new Set(filesDeleted)),
-                errors: results.filter(r => !r.success).map(r => r.error || 'Unknown error').filter(Boolean),
-                validationChecks: [
-                    {
-                        check: 'All sub-plans executed',
-                        passed: completedCount === updatedSubPlans.length,
-                        message: `${completedCount}/${updatedSubPlans.length} sub-plans completed`,
-                    },
-                    {
-                        check: 'No rollbacks required',
-                        passed: !rollbackOccurred.value,
-                        message: rollbackOccurred.value ? 'Rollback occurred during execution' : 'No rollbacks',
-                    },
-                ],
-                metrics: {
-                    changesApplied: completedCount,
-                    changesProposed: updatedSubPlans.length,
-                },
-                additionalContext: {
-                    query: plan.goal,
-                    codebaseId: codebaseInfo?.codebaseId,
-                    toolCalls: toolCalls.map(tc => `${tc.tool}: ${tc.success ? 'success' : 'failed'}`),
-                    rollbackOccurred: rollbackOccurred.value,
-                },
-            }).catch(error => {
-                // Non-blocking - log but don't fail execution
-                console.warn('[ExecutionAgent] Validation recording failed (non-critical):', error);
-                return null;
-            });
-            return {
-                plan: updatedPlan,
-                results,
-                overallSuccess: planStatus === 'completed',
-                completedSubPlans: completedCount,
-                totalSubPlans: updatedSubPlans.length,
-                ...(validationResult ? {
-                    validationSummary: validationResult.summary,
-                    feedbackId: validationResult.feedbackId || undefined,
-                    runId: validationResult.runId || undefined,
-                } : {}),
-            };
-        }
-        catch (error) {
-            // Record failure in validation
-            await agentValidationHelper.completeAgentOperation(validationContext, null, {
-                outcome: 'failure',
-                errors: [error instanceof Error ? error.message : String(error)],
-                additionalContext: {
-                    query: plan.goal,
-                    codebaseId: codebaseInfo?.codebaseId,
-                },
-            }).catch(() => {
-                // Non-blocking
-            });
-            throw error;
-        }
-    }
-    /**
-     * Commit successful changes to Git
-     * Only commits if there are actual file modifications
-     */
-    async commitSuccessfulChanges(plan, results) {
-        try {
-            // Check if we're in a git repo
-            const status = await this.gitTool.status();
-            const hasChanges = status.modified.length > 0 ||
-                status.staged.length > 0 ||
-                status.untracked.length > 0;
-            if (!hasChanges) {
-                return; // No changes to commit
-            }
-            // Generate commit message from plan
-            const commitMessage = `Codehere: ${plan.goal}\n\nCompleted ${results.length} sub-plan(s)`;
-            // Commit changes
-            const commitResult = await this.gitTool.commit(commitMessage);
-            if (!commitResult.success) {
-                // Log but don't fail - commit is optional
-                console.warn('⚠️  Failed to commit changes:', commitResult.error);
-            }
-        }
-        catch (error) {
-            // Silently fail - Git operations are optional
-            // Not all repos are Git repos, and that's okay
-        }
-    }
-    /**
-     * Mark sub-plans with failed dependencies as failed
-     */
-    markBlockedSubPlans(subPlans) {
-        const failed = new Set(subPlans.filter(sp => sp.status === 'failed').map(sp => sp.id));
-        subPlans.forEach((sp, index) => {
-            if (sp.status === 'pending') {
-                const failedDependencies = sp.dependencies.filter(depId => failed.has(depId));
-                if (failedDependencies.length > 0) {
-                    // Mark as failed due to dependency failure
-                    subPlans[index] = {
-                        ...sp,
-                        status: 'failed',
-                        error: `Blocked by failed dependency: ${failedDependencies.join(', ')}`,
-                    };
-                }
-            }
-        });
-    }
-    /**
-     * Get sub-plans ready for execution (dependencies satisfied)
-     */
-    getExecutableSubPlans(plan) {
-        const completed = new Set(plan.subPlans.filter(sp => sp.status === 'completed').map(sp => sp.id));
-        return plan.subPlans.filter(sp => sp.status === 'pending' &&
-            sp.dependencies.every(depId => completed.has(depId)));
-    }
-    /**
-     * Execute a single sub-plan
-     */
-    async executeSubPlan(subPlan, plan, context, tracking) {
-        const startTime = Date.now();
-        const observations = [];
-        try {
-            // For implement/edit/refactor sub-plans, use EditFileUseCase for better file creation support
-            if (subPlan.type === 'implement' || subPlan.type === 'edit' || subPlan.type === 'refactor') {
-                const params = this.extractParameters(subPlan, context);
-                if (params.filepath) {
-                    // Use EditFileUseCase which handles both editing and file creation
-                    const { EditFileUseCase } = await import('../use-cases/edit-file-use-case.js');
-                    const { container } = await import('../services/dependency-container.js');
-                    const editUseCase = new EditFileUseCase(this.aiService, container.verificationService, container.sastScanner);
-                    const editResult = await editUseCase.execute({
-                        filepath: params.filepath,
-                        instruction: params.instruction || subPlan.description,
-                        requirements: params.requirements || [],
-                    });
-                    // Track file changes
-                    if (editResult.edit) {
-                        const filepath = editResult.edit.filepath;
-                        if (editResult.edit.oldContent) {
-                            // File was edited
-                            if (!tracking.filesChanged.includes(filepath)) {
-                                tracking.filesChanged.push(filepath);
-                            }
-                        }
-                        else {
-                            // File was created
-                            if (!tracking.filesCreated.includes(filepath)) {
-                                tracking.filesCreated.push(filepath);
-                            }
-                        }
-                        // Track rollback if verification failed
-                        if (!editResult.success && editResult.verification && !editResult.verification.success) {
-                            tracking.rollbackOccurred.value = true;
-                        }
-                    }
-                    // Track tool call
-                    tracking.toolCalls.push({
-                        tool: 'EditFileUseCase',
-                        success: editResult.success,
-                        error: editResult.error,
-                    });
-                    // Trace tool execution
-                    agentValidationHelper.trace({
-                        operationType: 'tool_invocation',
-                        operationName: 'edit_file',
-                        input: { filepath: params.filepath },
-                        output: editResult.edit,
-                        error: editResult.error ? new Error(editResult.error) : undefined,
-                        metadata: {
-                            filepath: params.filepath,
-                            subPlanId: subPlan.id,
-                            tool: 'EditFileUseCase',
-                        },
-                    });
-                    const duration = Date.now() - startTime;
-                    return {
-                        subPlanId: subPlan.id,
-                        success: editResult.success,
-                        result: editResult.edit,
-                        error: editResult.error,
-                        observations: [{
-                                result: editResult.edit ? `File ${editResult.edit.filepath} ${editResult.edit.oldContent ? 'edited' : 'created'} successfully` : null,
-                                success: editResult.success,
-                                error: editResult.error,
-                            }],
-                        duration,
-                    };
-                }
-            }
-            // For other sub-plan types, use tool executor
-            const action = this.createActionFromSubPlan(subPlan, context);
-            // Track tool call
-            tracking.toolCalls.push({
-                tool: action.name,
-                success: true, // Will be updated after execution
-            });
-            // Trace tool execution start
-            agentValidationHelper.trace({
-                operationType: 'tool_invocation',
-                operationName: action.name,
-                input: { parameters: action.parameters },
-                metadata: {
-                    subPlanId: subPlan.id,
-                    tool: action.name,
-                },
-            });
-            const observation = await this.toolExecutor.executeAction(action);
-            // Update tool call tracking
-            const lastCall = tracking.toolCalls[tracking.toolCalls.length - 1];
-            if (lastCall && lastCall.tool === action.name) {
-                lastCall.success = observation.success;
-                lastCall.error = observation.error;
-            }
-            observations.push(observation);
-            // Extract file changes from tool results
-            if (observation.result) {
-                this.extractFilesFromToolResult(observation.result, tracking);
-            }
-            const duration = Date.now() - startTime;
-            return {
-                subPlanId: subPlan.id,
-                success: observation.success,
-                result: observation.result,
-                error: observation.error,
-                observations,
-                duration,
-            };
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            return {
-                subPlanId: subPlan.id,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                observations,
-                duration,
-            };
-        }
-    }
-    /**
-     * Create action from sub-plan
-     */
-    createActionFromSubPlan(subPlan, context) {
-        // Map sub-plan type to tool action
-        const toolMap = {
-            search: 'search',
-            edit: 'edit_replace',
-            refactor: 'edit_replace',
-            review: 'search', // Review uses search to find code
-            analyze: 'search',
-            implement: 'edit_create',
-            test: 'bash',
-            debug: 'edit_replace',
-        };
-        const toolName = toolMap[subPlan.type] || 'search';
-        // Extract parameters from sub-plan description
-        const parameters = this.extractParameters(subPlan, context);
-        return {
-            type: 'tool',
-            name: toolName,
-            parameters,
-        };
-    }
-    /**
-     * Extract action parameters from sub-plan description
-     */
-    extractParameters(subPlan, context) {
-        const params = {};
-        // Extract filepath if mentioned
-        const filepathMatch = subPlan.description.match(/(?:in|from|at|file)\s+([^\s]+\.(ts|js|tsx|jsx|py|java|go|rs|rb|php|vue|svelte|html|css|json|yaml|yml|md|txt|sh|bash))/i);
-        if (filepathMatch) {
-            params.filepath = filepathMatch[1];
-        }
-        // For search/review/analyze actions, use description as query
-        if (subPlan.type === 'search' || subPlan.type === 'analyze' || subPlan.type === 'review') {
-            params.query = subPlan.description;
-        }
-        // For edit/implement/refactor actions, extract instruction and filepath
-        if (subPlan.type === 'edit' || subPlan.type === 'implement' || subPlan.type === 'refactor') {
-            // Use the full description as instruction
-            params.instruction = subPlan.description;
-            // Try to extract filepath more intelligently - look for filepath at start or in description
-            if (!params.filepath) {
-                // Try pattern: "Create/Implement/Edit [filepath] to do X"
-                const filepathPatterns = [
-                    /(?:create|implement|edit|add|update)\s+(?:file\s+)?([^\s]+\.(ts|js|tsx|jsx|py|java|go|rs|rb|php|vue|svelte|html|css|json|yaml|yml|md|txt|sh|bash))/i,
-                    /(?:in|from|at|file)\s+([^\s]+\.(ts|js|tsx|jsx|py|java|go|rs|rb|php|vue|svelte|html|css|json|yaml|yml|md|txt|sh|bash))/i,
-                ];
-                for (const pattern of filepathPatterns) {
-                    const match = subPlan.description.match(pattern);
-                    if (match) {
-                        params.filepath = match[1];
-                        break;
-                    }
-                }
-            }
-            // Extract requirements if mentioned
-            if (subPlan.description.includes('with') || subPlan.description.includes('including')) {
-                // Simple requirement extraction - can be enhanced
-                const requirementsMatch = subPlan.description.match(/with\s+(.+?)(?:\.|$)/i);
-                if (requirementsMatch) {
-                    params.requirements = [requirementsMatch[1].trim()];
-                }
-            }
-        }
-        // Merge with context
-        return { ...context, ...params };
-    }
-    /**
-     * Extract files from execution results
-     */
-    extractFilesFromResults(results, filesChanged, filesCreated, filesDeleted) {
-        for (const result of results) {
-            if (result.result) {
-                this.extractFilesFromToolResult(result.result, {
-                    filesChanged,
-                    filesCreated,
-                    filesDeleted,
-                    toolCalls: [],
-                    rollbackOccurred: { value: false },
-                });
-            }
-        }
-    }
-    /**
-     * Extract file changes from tool result
-     */
-    extractFilesFromToolResult(result, tracking) {
-        // Handle EditResult
-        if (result && typeof result === 'object') {
-            if (result.filepath && typeof result.filepath === 'string') {
-                // Handle edit objects from EditFileUseCase
-                if (result.oldContent && !result.newContent) {
-                    // File was deleted
-                    if (!tracking.filesDeleted.includes(result.filepath)) {
-                        tracking.filesDeleted.push(result.filepath);
-                    }
-                }
-                else if (!result.oldContent && result.newContent) {
-                    // File was created
-                    if (!tracking.filesCreated.includes(result.filepath)) {
-                        tracking.filesCreated.push(result.filepath);
-                    }
-                }
-                else if (result.oldContent && result.newContent) {
-                    // File was edited
-                    if (!tracking.filesChanged.includes(result.filepath)) {
-                        tracking.filesChanged.push(result.filepath);
-                    }
-                }
-            }
-            // Handle operation field
-            if (result.operation === 'create' || result.operation === 'create_file') {
-                if (result.filepath && !tracking.filesCreated.includes(result.filepath)) {
-                    tracking.filesCreated.push(result.filepath);
-                }
-            }
-            else if (result.operation === 'str_replace') {
-                if (result.filepath && !tracking.filesChanged.includes(result.filepath)) {
-                    tracking.filesChanged.push(result.filepath);
-                }
-            }
-            else if (result.operation === 'undo') {
-                tracking.rollbackOccurred.value = true;
-            }
-        }
-        // Handle arrays (search results)
-        if (Array.isArray(result)) {
-            for (const item of result) {
-                if (item && typeof item === 'object' && item.filepath) {
-                    // Search results don't change files, just note them
-                }
-            }
-        }
-    }
-}
-//# sourceMappingURL=execution-agent.js.map