codehere 0.2.2 → 0.3.0-rc.10

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

@@ -1,433 +0,0 @@
-/**
- * Application Agent: Planning Agent (Architect)
- * Specialized agent for creating detailed, step-by-step modification plans
- *
- * Based on enterprise architecture: Separate Planning Agent from PlanningUseCase
- * Role: Creates detailed plans before execution
- */
-import { GitTool } from '../../tools/git-tool.js';
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-import { agentValidationHelper } from '../../infrastructure/validation/agent-validation-helper.js';
-export class PlanningAgent {
-    aiService;
-    memoryStream;
-    memoryRepository;
-    cwd;
-    decisionRecorder;
-    patternRepository;
-    knowledgeAccess;
-    gitTool;
-    constructor(aiService, memoryStream, memoryRepository, cwd = process.cwd(), decisionRecorder, // Optional - only record if provided
-    patternRepository, // Optional - for pattern suggestions
-    knowledgeAccess // Optional - for knowledge retrieval
-    ) {
-        this.aiService = aiService;
-        this.memoryStream = memoryStream;
-        this.memoryRepository = memoryRepository;
-        this.cwd = cwd;
-        this.decisionRecorder = decisionRecorder;
-        this.patternRepository = patternRepository;
-        this.knowledgeAccess = knowledgeAccess;
-        this.gitTool = new GitTool(cwd);
-    }
-    /**
-     * Create detailed modification plan
-     * This is the architect role - plans before execution
-     */
-    async createPlan(request) {
-        // Start validation context
-        const codebaseInfo = findCodebaseRoot(this.cwd);
-        const validationContext = agentValidationHelper.startAgentOperation('planning-agent', 'createPlan', {
-            query: request.goal,
-            codebaseId: codebaseInfo?.codebaseId,
-        });
-        try {
-            // Input validation - fail fast
-            if (!request.goal || request.goal.trim().length === 0) {
-                throw new Error('Goal cannot be empty');
-            }
-            // 1. Detect codebase context (for codebase-aware operations)
-            const codebaseId = codebaseInfo?.codebaseId;
-            const codebasePath = codebaseInfo?.rootPath;
-            // 2. Gather context: Git state, memories (filtered by codebase if available)
-            const gitContext = await this.gatherGitContext();
-            let recentMemories;
-            let relevantMemories;
-            if (codebaseId) {
-                // Use codebase-aware memory retrieval
-                recentMemories = await this.memoryRepository.findRecentByCodebase(codebaseId, 100);
-                relevantMemories = await this.memoryStream.retrieveByCodebase(request.goal, codebaseId, 50);
-            }
-            else {
-                // Fallback to global memory retrieval (backward compatibility)
-                recentMemories = await this.memoryRepository.findRecent(100);
-                relevantMemories = await this.memoryStream.retrieve(request.goal, 50);
-            }
-            // 2. Synthesize memories into reflections
-            // Skip synthesis if no memories - fail fast
-            const reflections = [];
-            const salientQuestions = [];
-            if (recentMemories.length > 0) {
-                // Only synthesize if we have meaningful memories (skip for speed)
-                // For now, use memory descriptions directly as reflections
-                // Full synthesis can be done asynchronously if needed
-                reflections.push(...recentMemories.slice(0, 5).map(m => m.description));
-            }
-            // 3. Retrieve relevant patterns for plan generation (if pattern repository available)
-            let relevantPatterns = [];
-            if (this.patternRepository && codebaseId) {
-                try {
-                    relevantPatterns = await this.patternRepository.search(codebaseId, request.goal, 5);
-                }
-                catch (error) {
-                    // Non-critical - pattern retrieval shouldn't fail planning
-                    console.warn('Pattern retrieval failed (non-critical):', error);
-                }
-            }
-            // 4. Generate hierarchical plan with detailed steps (including Git context and patterns)
-            const plan = await this.generateDetailedPlan(request.goal, reflections, relevantMemories, request.context, gitContext, relevantPatterns);
-            // 5. Assess plan confidence
-            const confidence = await this.assessPlanConfidence(plan, relevantMemories);
-            // 6. Store plan in memory (with codebase context)
-            await this.memoryStream.recordPlan(`Planning Agent created plan for: "${request.goal}"`, plan, codebaseId, codebasePath);
-            // 7. Extract and record decisions from planning context (if decision recorder available)
-            if (this.decisionRecorder && codebaseId) {
-                try {
-                    await this.decisionRecorder.extractDecisionFromPlanning({
-                        goal: request.goal,
-                        plan,
-                        constraints: request.context?.constraints,
-                    }, codebaseId, this.aiService);
-                }
-                catch (error) {
-                    // Don't fail planning if decision recording fails
-                    console.warn('Decision recording failed (non-critical):', error);
-                }
-            }
-            // Calculate plan metrics for validation
-            const planComplexity = plan.metadata?.complexity || 'medium';
-            const unresolvedDependencies = plan.subPlans.filter(sp => sp.dependencies.some(depId => !plan.subPlans.find(sp2 => sp2.id === depId)));
-            // Complete validation and get summary
-            const validationResult = await agentValidationHelper.completeAgentOperation(validationContext, {
-                plan,
-                reflections,
-                salientQuestions,
-                memoriesUsed: relevantMemories,
-                confidence,
-            }, {
-                outcome: 'success',
-                validationChecks: [
-                    {
-                        check: 'Plan generated',
-                        passed: true,
-                        message: `Plan with ${plan.subPlans.length} sub-plans created`,
-                    },
-                    {
-                        check: 'Dependencies resolved',
-                        passed: unresolvedDependencies.length === 0,
-                        message: unresolvedDependencies.length === 0
-                            ? 'All dependencies resolved'
-                            : `${unresolvedDependencies.length} unresolved dependencies`,
-                    },
-                    {
-                        check: 'Plan complexity assessed',
-                        passed: true,
-                        message: `Complexity: ${planComplexity}`,
-                    },
-                ],
-                metrics: {
-                    changesProposed: plan.subPlans.length,
-                },
-                additionalContext: {
-                    query: request.goal,
-                    codebaseId,
-                    codebaseType: codebaseInfo?.type,
-                    planComplexity,
-                    numberOfSteps: plan.subPlans.length,
-                    unresolvedDependencies: unresolvedDependencies.length,
-                    riskEstimation: plan.metadata?.complexity === 'complex' ? 'high' :
-                        plan.metadata?.complexity === 'simple' ? 'low' : 'medium',
-                },
-            });
-            return {
-                plan,
-                reflections,
-                salientQuestions,
-                memoriesUsed: relevantMemories,
-                confidence,
-                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: request.goal,
-                    codebaseId: codebaseInfo?.codebaseId,
-                },
-            });
-            throw error;
-        }
-    }
-    /**
-     * Gather Git context for planning
-     */
-    async gatherGitContext() {
-        try {
-            const status = await this.gitTool.status();
-            // status returns: { branch, modified, staged, untracked }
-            const currentBranch = status.branch;
-            const uncommittedFiles = [
-                ...status.modified,
-                ...status.staged,
-                ...status.untracked,
-            ];
-            const hasUncommittedChanges = uncommittedFiles.length > 0;
-            // Get recent commits (last 5)
-            const log = await this.gitTool.log(5);
-            const recentCommits = [];
-            if (Array.isArray(log)) {
-                for (const commit of log.slice(0, 5)) {
-                    recentCommits.push(commit.hash.substring(0, 12)); // Short hash
-                }
-            }
-            return {
-                currentBranch,
-                hasUncommittedChanges,
-                uncommittedFiles,
-                recentCommits,
-            };
-        }
-        catch {
-            // Git not available or not a git repo
-            return {
-                hasUncommittedChanges: false,
-                uncommittedFiles: [],
-                recentCommits: [],
-            };
-        }
-    }
-    /**
-     * Generate detailed hierarchical plan
-     */
-    async generateDetailedPlan(goal, reflections, memories, context, gitContext, relevantPatterns = [], relevantKnowledge = []) {
-        const memoryContext = memories.map(m => `- ${m.description} (Type: ${m.type})`).join('\n');
-        const reflectionContext = reflections.map(r => `- ${r}`).join('\n');
-        const fileContext = context?.files && context.files.length > 0
-            ? `\n\n**IMPORTANT - FILES CONSTRAINT:**\nYou MUST focus on these specific files: ${context.files.join(', ')}\nEach sub-plan that modifies code MUST reference one of these files explicitly in its description (e.g., "Edit ${context.files[0]} to...").`
-            : '';
-        const constraintsContext = context?.constraints
-            ? `\n\nConstraints: ${context.constraints.join(', ')}`
-            : '';
-        // Git context
-        let gitContextText = '';
-        if (gitContext) {
-            gitContextText = `\n\nGit Context:`;
-            if (gitContext.currentBranch) {
-                gitContextText += `\n- Current branch: ${gitContext.currentBranch}`;
-            }
-            if (gitContext.hasUncommittedChanges) {
-                gitContextText += `\n- Uncommitted changes in: ${gitContext.uncommittedFiles.slice(0, 5).join(', ')}${gitContext.uncommittedFiles.length > 5 ? '...' : ''}`;
-                gitContextText += `\n⚠️  WARNING: There are uncommitted changes. Consider committing or stashing before making modifications.`;
-            }
-            if (gitContext.recentCommits.length > 0) {
-                gitContextText += `\n- Recent commits: ${gitContext.recentCommits.join(', ')}`;
-            }
-        }
-        // Detect if this is a multi-file operation
-        const isMultiFile = /(refactor|migrate|update|implement|create|add|introduce).*(system|codebase|all|multiple|several|across|architecture|pattern|components|layer|abstraction)/i.test(goal);
-        // Detect if this requires file/directory creation (architecture patterns, new layers, etc.)
-        const requiresFileCreation = /(add|create|introduce).*(repository|service|controller|middleware|pattern|layer|abstraction|directory|folder|file)/i.test(goal) ||
-            /(repository|service|controller|middleware)\s+(pattern|layer)/i.test(goal);
-        const multiFileGuidance = isMultiFile ? `
-    
-    **IMPORTANT - MULTI-FILE OPERATION DETECTED:**
-    This goal requires changes across multiple files. Your plan MUST:
-    1. Create separate sub-plans for EACH file that needs modification or creation
-    2. Include sub-plans to search and identify ALL files that need changes
-    3. Specify the exact filepath in each sub-plan description (e.g., "Edit src/auth/auth-service.ts to add JWT" or "Create src/repositories/user-repository.ts")
-    4. Ensure dependencies are set correctly (search → edit file 1 → edit file 2)
-    5. For file creation, use type "implement" and include the full filepath in the description
-    6. Coordinate changes across files to ensure consistency
-    ${requiresFileCreation ? `
-    
-    **FILE CREATION REQUIRED:**
-    This operation requires creating new files/directories. For each new file:
-    - Use type "implement" in the sub-plan
-    - Include the full directory path in the description (e.g., "Create src/repositories/user-repository.ts")
-    - Ensure parent directories are created as needed
-    - For patterns like "repository pattern", create:
-      * Interface files (e.g., "src/repositories/interfaces/user-repository.interface.ts")
-      * Implementation files (e.g., "src/repositories/user-repository.ts")
-      * Update existing files to use the new pattern
-    ` : ''}
-    
-    Example multi-file plan structure:
-    - Sub-plan 1: "Search codebase for authentication-related files"
-    - Sub-plan 2: "Edit src/auth/auth-service.ts to implement JWT token generation"
-    - Sub-plan 3: "Edit src/auth/middleware.ts to add JWT validation middleware"
-    - Sub-plan 4: "Update src/config/auth-config.ts to include JWT settings"
-    ${requiresFileCreation ? `
-    Example file creation plan structure:
-    - Sub-plan 1: "Search codebase for data access patterns"
-    - Sub-plan 2: "Create src/repositories/interfaces/user-repository.interface.ts with IUserRepository interface"
-    - Sub-plan 3: "Create src/repositories/user-repository.ts implementing IUserRepository"
-    - Sub-plan 4: "Update src/services/user-service.ts to use UserRepository instead of direct data access"
-    ` : ''}
-    ` : '';
-        const prompt = `You are a Planning Agent (Architect) for an AI coding system. Your role is to create detailed, step-by-step modification plans.
-
-    Goal: "${goal}"${fileContext}${constraintsContext}${gitContextText}${multiFileGuidance}
-
-    Consider:
-    - **Relevant Past Experiences/Memories**:
-    ${memoryContext || 'No relevant past experiences.'}
-    - **Synthesized Reflections/Insights**:
-    ${reflectionContext || 'No specific reflections.'}
-    ${relevantPatterns.length > 0 ? `
-    - **Relevant Patterns from Codebase**:
-    ${relevantPatterns.map(p => `  - ${p.name}: ${p.description}${p.codeExample ? `\n    Example: ${p.codeExample.substring(0, 200)}...` : ''}`).join('\n')}
-    
-    **IMPORTANT**: Consider reusing or following these existing patterns from the codebase when creating your plan.
-    ` : ''}
-
-    Create a detailed plan with:
-    1. Clear sub-plans with specific actions
-    2. Dependencies between sub-plans
-    3. Estimated complexity for each sub-plan
-    4. Required tools/resources for each step
-
-    For each sub-plan, specify:
-    - \`id\`: Unique identifier (e.g., "subplan_1")
-    - \`description\`: Clear, actionable description WITH filepath if applicable (e.g., "Edit src/auth/auth-service.ts to add JWT")
-    - \`type\`: Action type (search, edit, refactor, review, analyze, implement, test, debug)
-    - \`dependencies\`: Array of sub-plan IDs that must complete first
-    - \`status\`: Always "pending" initially
-    - \`estimatedComplexity\`: "low" | "medium" | "high"
-    - \`requiredTools\`: Array of tool names needed (e.g., ["search", "edit"])
-
-    ${isMultiFile ? '**For multi-file operations, create one sub-plan per file, each with explicit filepath in description.**' : ''}
-    
-    Respond with ONLY a JSON array of sub-plan objects.
-
-    Example:
-    [
-      {
-        "id": "subplan_1",
-        "description": "Search codebase for existing authentication patterns",
-        "type": "search",
-        "dependencies": [],
-        "status": "pending",
-        "estimatedComplexity": "low",
-        "requiredTools": ["search"]
-      },
-      {
-        "id": "subplan_2",
-        "description": "Implement JWT token generation in src/auth/jwt.ts",
-        "type": "implement",
-        "dependencies": ["subplan_1"],
-        "status": "pending",
-        "estimatedComplexity": "high",
-        "requiredTools": ["edit", "bash"]
-      }
-    ]
-
-    JSON only, no other text:`;
-        let response;
-        try {
-            // Add timeout protection for planning calls (60 seconds max)
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Planning API call timed out after 60 seconds')), 60000);
-            });
-            response = await Promise.race([
-                this.aiService.chat(prompt, []),
-                timeoutPromise,
-            ]);
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            console.error('Planning Agent: API call failed:', errorMsg);
-            // Provide more helpful error messages
-            if (errorMsg.includes('timeout') || errorMsg.includes('timed out')) {
-                throw new Error(`Failed to generate plan: API call timed out. The Cohere API may be slow or unresponsive. Please check your API key and network connection.`);
-            }
-            else if (errorMsg.includes('401') || errorMsg.includes('Unauthorized')) {
-                throw new Error(`Failed to generate plan: API authentication failed. Please check your COHERE_API_KEY is valid.`);
-            }
-            else if (errorMsg.includes('429') || errorMsg.includes('rate limit') || errorMsg.includes('TooManyRequests')) {
-                // Check if it's a trial key monthly limit
-                const isTrialLimit = errorMsg.includes('Trial key') || errorMsg.includes('1000 API calls');
-                if (isTrialLimit) {
-                    throw new Error(`Failed to generate plan: Trial API key has reached monthly limit (1000 calls/month). Please upgrade to a Production key or wait for the limit to reset. See https://dashboard.cohere.com/api-keys`);
-                }
-                throw new Error(`Failed to generate plan: API rate limit exceeded (429). Please wait and try again or upgrade your API key.`);
-            }
-            throw new Error(`Failed to generate plan: API call failed. ${errorMsg}`);
-        }
-        // Check for empty response
-        if (!response || response.trim().length === 0) {
-            console.error('Planning Agent: Empty response from API');
-            throw new Error('Failed to generate plan: API returned empty response');
-        }
-        try {
-            // Try to extract JSON from response (handle cases where LLM adds extra text)
-            let jsonStr = response.trim();
-            // Try to find JSON array in response
-            const jsonArrayMatch = jsonStr.match(/\[[\s\S]*\]/);
-            if (jsonArrayMatch) {
-                jsonStr = jsonArrayMatch[0];
-            }
-            const subPlans = JSON.parse(jsonStr);
-            // Validate subPlans
-            if (!Array.isArray(subPlans) || subPlans.length === 0) {
-                console.error('Planning Agent: Invalid subPlans array:', subPlans);
-                throw new Error('Failed to generate plan: API returned empty or invalid sub-plans array');
-            }
-            return {
-                id: `plan_${Date.now()}`,
-                goal,
-                description: goal,
-                subPlans,
-                status: 'draft',
-                createdAt: new Date(),
-                updatedAt: new Date(),
-                dependencies: [],
-                metadata: {
-                    memoriesUsed: memories.map(m => m.id || ''),
-                    reflections: reflections,
-                    complexity: 'medium',
-                    priority: 5,
-                },
-            };
-        }
-        catch (e) {
-            // User-friendly error for minimal mode
-            console.error('Planning agent returned an unexpected response.');
-            console.error('This is usually a provider/model issue. Try again or check your AI provider configuration.');
-            // Verbose details for debugging (when CODEHERE_CLI_STYLE=verbose)
-            if (process.env.CODEHERE_CLI_STYLE === 'verbose') {
-                console.error('\nDebug details:');
-                console.error('  Response length:', response?.length || 0);
-                console.error('  Response preview:', response?.substring(0, 200) || 'empty');
-                console.error('  Parse error:', e instanceof Error ? e.message : String(e));
-            }
-            throw new Error(`Planning failed: AI response was not valid JSON. Try again or switch providers.`);
-        }
-    }
-    /**
-     * Assess confidence in plan quality
-     */
-    async assessPlanConfidence(plan, memories) {
-        // Simple heuristic: more memories = higher confidence
-        // More detailed sub-plans = higher confidence
-        const memoryFactor = Math.min(memories.length / 10, 1.0);
-        const detailFactor = Math.min(plan.subPlans.length / 5, 1.0);
-        const dependencyFactor = plan.subPlans.some(sp => sp.dependencies.length > 0) ? 0.2 : 0;
-        return Math.min(memoryFactor * 0.4 + detailFactor * 0.4 + dependencyFactor, 1.0);
-    }
-}
-//# sourceMappingURL=planning-agent.js.map