@compass-ai/nova 1.0.72 → 1.0.74

package/dist/services/llm-plan-generator.js

@@ -0,0 +1,863 @@
+/**
+ * LLM-Powered Plan Generator
+ *
+ * This module generates implementation plans using Claude AI instead of
+ * hardcoded pattern matching. It sends context about the project and user
+ * request to Claude and receives a structured ImplementationPlan in response.
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { getAnthropicClient } from './anthropic-client.js';
+import { logger } from '../utils/logger.js';
+import { getEventEmitter } from '../core/event-emitter.js';
+import { IMPLEMENTATION_PLAN_SCHEMA, PLAN_GENERATION_SYSTEM_PROMPT, PLAN_ADOPTION_SYSTEM_PROMPT, PLAN_MODIFICATION_SYSTEM_PROMPT, buildPlanModificationUserPrompt, buildLightweightPlanModificationPrompt, } from '../prompts/index.js';
+/**
+ * Emits a status message for UI display during plan generation.
+ */
+function emitStatus(toolCallId, message) {
+    if (toolCallId) {
+        const eventEmitter = getEventEmitter();
+        eventEmitter.emit('tool-status-message', { toolId: toolCallId, message });
+    }
+}
+/**
+ * Plan generation phases in order of appearance in JSON output.
+ */
+var PlanPhase;
+(function (PlanPhase) {
+    PlanPhase[PlanPhase["STARTING"] = 0] = "STARTING";
+    PlanPhase[PlanPhase["PROBLEM_STATEMENT"] = 1] = "PROBLEM_STATEMENT";
+    PlanPhase[PlanPhase["REQUIREMENTS"] = 2] = "REQUIREMENTS";
+    PlanPhase[PlanPhase["EDGE_CASES"] = 3] = "EDGE_CASES";
+    PlanPhase[PlanPhase["CONSTRAINTS"] = 4] = "CONSTRAINTS";
+    PlanPhase[PlanPhase["ASSUMPTIONS"] = 5] = "ASSUMPTIONS";
+    PlanPhase[PlanPhase["IMPACT"] = 6] = "IMPACT";
+    PlanPhase[PlanPhase["TASKS"] = 7] = "TASKS";
+    PlanPhase[PlanPhase["RISKS"] = 8] = "RISKS";
+    PlanPhase[PlanPhase["TESTING"] = 9] = "TESTING";
+    PlanPhase[PlanPhase["FINALIZING"] = 10] = "FINALIZING";
+})(PlanPhase || (PlanPhase = {}));
+/**
+ * Tracks plan generation progress by analyzing streamed JSON content.
+ * Uses a state machine to ensure orderly progression through phases.
+ */
+class PlanProgressTracker {
+    content = '';
+    lastEmittedMessage = '';
+    currentPhase = PlanPhase.STARTING;
+    requirementCount = 0;
+    taskCount = 0;
+    riskCount = 0;
+    /**
+     * Appends new content and returns a status message if progress changed.
+     */
+    update(chunk) {
+        this.content += chunk;
+        const message = this.detectProgress();
+        if (message && message !== this.lastEmittedMessage) {
+            this.lastEmittedMessage = message;
+            return message;
+        }
+        return null;
+    }
+    /**
+     * Detects progress using ordered phase transitions.
+     * Only moves forward through phases, never backward.
+     */
+    detectProgress() {
+        // Check phases in order - only advance, never go back
+        if (this.currentPhase < PlanPhase.PROBLEM_STATEMENT &&
+            this.content.includes('"problemStatement"')) {
+            this.currentPhase = PlanPhase.PROBLEM_STATEMENT;
+            return 'Defining problem statement...';
+        }
+        if (this.currentPhase < PlanPhase.REQUIREMENTS &&
+            this.content.includes('"requirements"')) {
+            this.currentPhase = PlanPhase.REQUIREMENTS;
+        }
+        // While in requirements phase, track count
+        if (this.currentPhase === PlanPhase.REQUIREMENTS) {
+            const count = (this.content.match(/"id":\s*"req-/g) || []).length;
+            if (count > this.requirementCount) {
+                this.requirementCount = count;
+                return `Generating requirements... (${count} found)`;
+            }
+        }
+        if (this.currentPhase < PlanPhase.EDGE_CASES &&
+            this.content.includes('"edgeCases"')) {
+            this.currentPhase = PlanPhase.EDGE_CASES;
+            return 'Identifying edge cases...';
+        }
+        if (this.currentPhase < PlanPhase.CONSTRAINTS &&
+            this.content.includes('"constraints"')) {
+            this.currentPhase = PlanPhase.CONSTRAINTS;
+            return 'Defining constraints...';
+        }
+        if (this.currentPhase < PlanPhase.ASSUMPTIONS &&
+            this.content.includes('"assumptions"')) {
+            this.currentPhase = PlanPhase.ASSUMPTIONS;
+            return 'Documenting assumptions...';
+        }
+        if (this.currentPhase < PlanPhase.IMPACT &&
+            this.content.includes('"impact"')) {
+            this.currentPhase = PlanPhase.IMPACT;
+            return 'Analyzing file impact...';
+        }
+        if (this.currentPhase < PlanPhase.TASKS &&
+            this.content.includes('"tasks"')) {
+            this.currentPhase = PlanPhase.TASKS;
+        }
+        // While in tasks phase, track count
+        if (this.currentPhase === PlanPhase.TASKS) {
+            const count = (this.content.match(/"id":\s*"task-/g) || []).length;
+            if (count > this.taskCount) {
+                this.taskCount = count;
+                return `Creating tasks... (${count} defined)`;
+            }
+        }
+        if (this.currentPhase < PlanPhase.RISKS &&
+            this.content.includes('"risks"')) {
+            this.currentPhase = PlanPhase.RISKS;
+        }
+        // While in risks phase, track count
+        if (this.currentPhase === PlanPhase.RISKS) {
+            const count = (this.content.match(/"severity":\s*"/g) || []).length;
+            if (count > this.riskCount) {
+                this.riskCount = count;
+                return `Identifying risks... (${count} found)`;
+            }
+        }
+        if (this.currentPhase < PlanPhase.TESTING &&
+            this.content.includes('"testing"')) {
+            this.currentPhase = PlanPhase.TESTING;
+            return 'Defining test strategy...';
+        }
+        if (this.currentPhase < PlanPhase.FINALIZING &&
+            this.content.includes('"rollbackStrategy"')) {
+            this.currentPhase = PlanPhase.FINALIZING;
+            return 'Finalizing plan...';
+        }
+        // Default based on current phase
+        if (this.currentPhase === PlanPhase.STARTING) {
+            return 'Generating plan...';
+        }
+        return this.lastEmittedMessage || 'Generating plan...';
+    }
+    /**
+     * Returns final summary of what was generated.
+     */
+    getSummary() {
+        return `Generated plan with ${this.requirementCount} requirements, ${this.taskCount} tasks, ${this.riskCount} risks`;
+    }
+}
+/**
+ * Builds the system prompt for plan generation.
+ * Uses the centralized prompt from the prompts module.
+ */
+function buildSystemPrompt() {
+    return PLAN_GENERATION_SYSTEM_PROMPT;
+}
+/**
+ * Builds the user prompt with all context for plan generation.
+ */
+function buildUserPrompt(userRequest, context, complexity, clarifications) {
+    const parts = [];
+    // User Request
+    parts.push('## User Request');
+    parts.push(userRequest);
+    parts.push('');
+    // Project Context
+    parts.push('## Project Context');
+    parts.push(`**Project Root:** ${context.projectRoot}`);
+    parts.push(`**Project Type:** ${context.projectType || 'unknown'}`);
+    parts.push(`**Languages:** ${context.languages.join(', ') || 'unknown'}`);
+    parts.push('');
+    // Directory Structure
+    if (context.directoryTree) {
+        parts.push('### Directory Structure');
+        parts.push('```');
+        parts.push(context.directoryTree.substring(0, 2000)); // Limit size
+        parts.push('```');
+        parts.push('');
+    }
+    // Relevant Files
+    if (context.relevantFiles.length > 0) {
+        parts.push('### Relevant Files');
+        for (const file of context.relevantFiles.slice(0, 15)) {
+            parts.push(`- \`${file.path}\` (${file.reason})`);
+        }
+        parts.push('');
+    }
+    // Affected Areas
+    if (context.affectedAreas.length > 0) {
+        parts.push('### Affected Areas');
+        parts.push(context.affectedAreas.join(', '));
+        parts.push('');
+    }
+    // Complexity Assessment
+    parts.push('## Complexity Assessment');
+    parts.push(`- **Mode:** ${complexity.mode}`);
+    parts.push(`- **Confidence:** ${complexity.confidence}%`);
+    parts.push(`- **Files Affected:** ${complexity.factors.filesAffected}`);
+    parts.push(`- **Architectural Change:** ${complexity.factors.architecturalChange}`);
+    parts.push(`- **Breaking Changes:** ${complexity.factors.breakingChanges}`);
+    parts.push(`- **Risk Level:** ${complexity.factors.riskLevel}/10`);
+    parts.push(`- **Reasoning:** ${complexity.reasoning}`);
+    parts.push('');
+    // Clarifications (if any)
+    if (clarifications && clarifications.qaRecords.length > 0) {
+        parts.push('## User Clarifications');
+        for (const qa of clarifications.qaRecords) {
+            parts.push(`**Q:** ${qa.question.question}`);
+            const answer = Array.isArray(qa.answer.answer)
+                ? qa.answer.answer.join(', ')
+                : qa.answer.answer;
+            parts.push(`**A:** ${answer}`);
+            parts.push('');
+        }
+    }
+    // Git Context
+    if (context.gitContext) {
+        parts.push('## Git Context');
+        parts.push(`- **Current Branch:** ${context.gitContext.currentBranch}`);
+        parts.push(`- **Working Directory Clean:** ${context.gitContext.isClean}`);
+        if (context.gitContext.uncommittedChanges.length > 0) {
+            parts.push(`- **Uncommitted Changes:** ${context.gitContext.uncommittedChanges.length} files`);
+        }
+        parts.push('');
+    }
+    // Task
+    parts.push('## Task');
+    parts.push('Generate a detailed implementation plan as JSON matching this schema:');
+    parts.push('```json');
+    parts.push(IMPLEMENTATION_PLAN_SCHEMA);
+    parts.push('```');
+    parts.push('');
+    parts.push('Requirements:');
+    parts.push('- Create 3-10 specific, actionable tasks');
+    parts.push('- Each task should target specific files from this project');
+    parts.push('- Include realistic task dependencies');
+    parts.push('- Identify concrete risks with mitigations specific to this codebase');
+    parts.push('- Be specific to THIS request - do not use generic placeholders');
+    parts.push('- File paths should be relative to the project root');
+    parts.push('');
+    parts.push('Respond with ONLY the JSON object, no other text.');
+    return parts.join('\n');
+}
+/**
+ * Parses the LLM response into an ImplementationPlan.
+ * Handles potential JSON parsing errors and validates the structure.
+ */
+function parsePlanResponse(response) {
+    // Try to extract JSON from the response (in case there's extra text)
+    let jsonStr = response.trim();
+    // Remove markdown code blocks if present
+    if (jsonStr.startsWith('```json')) {
+        jsonStr = jsonStr.slice(7);
+    }
+    else if (jsonStr.startsWith('```')) {
+        jsonStr = jsonStr.slice(3);
+    }
+    if (jsonStr.endsWith('```')) {
+        jsonStr = jsonStr.slice(0, -3);
+    }
+    jsonStr = jsonStr.trim();
+    // Try to parse the JSON
+    const parsed = JSON.parse(jsonStr);
+    return parsed;
+}
+/**
+ * Validates and fills in missing fields in the parsed plan.
+ */
+function validateAndFillPlan(partial, userRequest) {
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    // Ensure tasks have proper IDs and order
+    const tasks = (partial.tasks || []).map((task, index) => ({
+        id: task.id || `task-${uuidv4().slice(0, 8)}`,
+        order: task.order || index + 1,
+        description: task.description || 'No description',
+        targetFiles: task.targetFiles || [],
+        targetElements: task.targetElements || [],
+        changes: task.changes || '',
+        dependencies: task.dependencies || [],
+        verificationCriteria: task.verificationCriteria || [],
+        complexity: task.complexity || 5,
+        requirementRefs: task.requirementRefs || [],
+    }));
+    // Ensure requirements have IDs
+    const requirements = (partial.requirements || []).map((req) => ({
+        id: req.id || `req-${uuidv4().slice(0, 8)}`,
+        description: req.description || userRequest,
+        priority: req.priority || 1,
+        source: req.source || 'user',
+    }));
+    // Default requirement if none provided
+    if (requirements.length === 0) {
+        requirements.push({
+            id: `req-${uuidv4().slice(0, 8)}`,
+            description: userRequest,
+            priority: 1,
+            source: 'user',
+        });
+    }
+    // Ensure edge cases have proper structure
+    const edgeCases = (partial.edgeCases || []).map((ec) => ({
+        description: ec.description || '',
+        handling: ec.handling || '',
+        risk: ec.risk || 'medium',
+    }));
+    // Ensure risks have proper structure
+    const risks = (partial.risks || []).map((risk) => ({
+        description: risk.description || '',
+        severity: risk.severity || 'medium',
+        mitigation: risk.mitigation || '',
+        rollback: risk.rollback,
+    }));
+    // Ensure file operations have proper structure
+    const fileOperations = (partial.impact?.fileOperations || []).map((op) => ({
+        path: op.path || '',
+        operation: op.operation || 'create',
+        changes: op.changes,
+    }));
+    // Calculate total complexity from tasks
+    const totalComplexity = partial.totalComplexity ||
+        Math.round(tasks.reduce((sum, t) => sum + t.complexity, 0) / Math.max(tasks.length, 1));
+    // Build summary if not provided
+    const summary = partial.summary ||
+        `Plan with ${tasks.length} tasks, ${risks.length} risks identified. Total complexity: ${totalComplexity}/10`;
+    // Generate title from problem statement if not provided
+    const title = partial.title ||
+        (partial.problemStatement
+            ? partial.problemStatement.split(/[.!?\n]/)[0].trim().substring(0, 80)
+            : userRequest.split(/[.!?\n]/)[0].trim().substring(0, 80));
+    return {
+        id,
+        createdAt: now,
+        version: 1,
+        title,
+        problemStatement: partial.problemStatement || userRequest,
+        requirements,
+        edgeCases,
+        constraints: partial.constraints || [],
+        assumptions: partial.assumptions || [],
+        impact: {
+            fileOperations,
+            dependenciesAffected: partial.impact?.dependenciesAffected || [],
+            breakingChanges: partial.impact?.breakingChanges || [],
+            migrations: partial.impact?.migrations,
+        },
+        tasks,
+        risks,
+        testing: {
+            unitTests: partial.testing?.unitTests || [],
+            integrationTests: partial.testing?.integrationTests || [],
+            testFiles: partial.testing?.testFiles || [],
+        },
+        rollbackStrategy: partial.rollbackStrategy || 'Use git to revert changes',
+        totalComplexity,
+        complexityNote: partial.complexityNote,
+        summary,
+    };
+}
+/**
+ * Generates an implementation plan using Claude AI.
+ *
+ * @param userRequest - The user's original request
+ * @param context - Gathered project context
+ * @param complexity - Complexity classification results
+ * @param clarifications - Optional clarification results
+ * @param toolCallId - Optional tool call ID for status updates
+ * @returns A detailed implementation plan
+ */
+export async function generatePlanWithLLM(userRequest, context, complexity, clarifications, toolCallId) {
+    logger.info('Generating implementation plan with LLM', {
+        projectType: context.projectType,
+        complexityMode: complexity.mode,
+        relevantFiles: context.relevantFiles.length,
+    });
+    const startTime = Date.now();
+    try {
+        // Get the Anthropic client
+        emitStatus(toolCallId, 'Initializing plan generation...');
+        const client = await getAnthropicClient();
+        if (!client.isInitialized()) {
+            await client.initialize();
+        }
+        // Build prompts
+        emitStatus(toolCallId, 'Analyzing project context...');
+        const systemPrompt = buildSystemPrompt();
+        const userPrompt = buildUserPrompt(userRequest, context, complexity, clarifications);
+        // Stream the response with progress tracking
+        emitStatus(toolCallId, 'Generating plan...');
+        const progressTracker = new PlanProgressTracker();
+        let fullContent = '';
+        // Use streaming to track progress
+        for await (const response of client.streamMessage([{ role: 'user', content: userPrompt }], {
+            system: systemPrompt,
+            maxTokens: 8192,
+            temperature: 0.4, // Conservative temperature for consistent structured output
+        })) {
+            if (response.type === 'text' && response.content) {
+                fullContent += response.content;
+                // Update progress based on streamed content
+                const progressMessage = progressTracker.update(response.content);
+                if (progressMessage) {
+                    emitStatus(toolCallId, progressMessage);
+                }
+            }
+            else if (response.type === 'error') {
+                throw new Error(response.error || 'Unknown streaming error');
+            }
+        }
+        logger.debug('LLM plan generation response received', {
+            contentLength: fullContent.length,
+            summary: progressTracker.getSummary(),
+        });
+        // Parse the response
+        emitStatus(toolCallId, 'Parsing plan...');
+        const parsedPlan = parsePlanResponse(fullContent);
+        // Validate and fill in missing fields
+        emitStatus(toolCallId, 'Validating plan structure...');
+        const plan = validateAndFillPlan(parsedPlan, userRequest);
+        const duration = Date.now() - startTime;
+        logger.info('Plan generated successfully', {
+            planId: plan.id,
+            taskCount: plan.tasks.length,
+            riskCount: plan.risks.length,
+            totalComplexity: plan.totalComplexity,
+            duration: `${duration}ms`,
+        });
+        return plan;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error('Failed to generate plan with LLM', { error: errorMessage });
+        // Return a fallback plan on error
+        return createFallbackPlan(userRequest, context, complexity, errorMessage);
+    }
+}
+/**
+ * Creates a fallback plan when LLM generation fails.
+ */
+function createFallbackPlan(userRequest, context, complexity, errorReason) {
+    logger.warn('Creating fallback plan due to LLM error', { errorReason });
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    return {
+        id,
+        createdAt: now,
+        version: 1,
+        title: userRequest.split(/[.!?\n]/)[0].trim().substring(0, 80) || 'Implementation Plan',
+        problemStatement: `${userRequest}\n\n[Note: LLM plan generation failed: ${errorReason}. This is a basic fallback plan.]`,
+        requirements: [
+            {
+                id: `req-${uuidv4().slice(0, 8)}`,
+                description: userRequest,
+                priority: 1,
+                source: 'user',
+            },
+        ],
+        edgeCases: [],
+        constraints: [`Project type: ${context.projectType || 'unknown'}`],
+        assumptions: ['Development environment is properly configured'],
+        impact: {
+            fileOperations: [],
+            dependenciesAffected: [],
+            breakingChanges: [],
+        },
+        tasks: [
+            {
+                id: `task-${uuidv4().slice(0, 8)}`,
+                order: 1,
+                description: 'Analyze requirements and existing codebase',
+                targetFiles: context.relevantFiles.slice(0, 5).map((f) => f.path),
+                targetElements: [],
+                changes: 'Review existing code patterns and plan implementation',
+                dependencies: [],
+                verificationCriteria: ['Requirements understood'],
+                complexity: 3,
+                requirementRefs: [],
+            },
+            {
+                id: `task-${uuidv4().slice(0, 8)}`,
+                order: 2,
+                description: 'Implement the requested functionality',
+                targetFiles: [],
+                targetElements: [],
+                changes: userRequest,
+                dependencies: [],
+                verificationCriteria: ['Functionality works as expected'],
+                complexity: complexity.factors.filesAffected > 5 ? 7 : 5,
+                requirementRefs: [],
+            },
+            {
+                id: `task-${uuidv4().slice(0, 8)}`,
+                order: 3,
+                description: 'Test and verify implementation',
+                targetFiles: [],
+                targetElements: [],
+                changes: 'Write tests and verify functionality',
+                dependencies: [],
+                verificationCriteria: ['All tests pass'],
+                complexity: 3,
+                requirementRefs: [],
+            },
+        ],
+        risks: [
+            {
+                description: 'LLM plan generation failed - using basic fallback plan',
+                severity: 'medium',
+                mitigation: 'Proceed carefully and verify each step manually',
+                rollback: 'Use git to revert changes if needed',
+            },
+        ],
+        testing: {
+            unitTests: ['Test new functionality'],
+            integrationTests: [],
+            testFiles: [],
+        },
+        rollbackStrategy: 'Use git to revert all changes',
+        totalComplexity: complexity.factors.riskLevel,
+        summary: `Fallback plan for: ${userRequest.substring(0, 100)}...`,
+    };
+}
+/**
+ * Builds the user prompt for plan adoption.
+ * Uses the user's structured input as the plan source.
+ */
+function buildAdoptionUserPrompt(userProvidedPlan, context, adoptedPlanSummary) {
+    const parts = [];
+    // User's Plan (the source of truth)
+    parts.push('## User-Provided Plan');
+    parts.push('The following is the user\'s structured plan. PRESERVE this structure:');
+    parts.push('');
+    parts.push(userProvidedPlan);
+    parts.push('');
+    if (adoptedPlanSummary) {
+        parts.push('## Detected Structure');
+        parts.push(adoptedPlanSummary);
+        parts.push('');
+    }
+    // Project Context (for enrichment)
+    parts.push('## Project Context (use to enrich the plan)');
+    parts.push(`**Project Root:** ${context.projectRoot}`);
+    parts.push(`**Project Type:** ${context.projectType || 'unknown'}`);
+    parts.push(`**Languages:** ${context.languages.join(', ') || 'unknown'}`);
+    parts.push('');
+    // Directory Structure
+    if (context.directoryTree) {
+        parts.push('### Directory Structure');
+        parts.push('```');
+        parts.push(context.directoryTree.substring(0, 2000));
+        parts.push('```');
+        parts.push('');
+    }
+    // Relevant Files
+    if (context.relevantFiles.length > 0) {
+        parts.push('### Relevant Files (use to populate targetFiles)');
+        for (const file of context.relevantFiles.slice(0, 15)) {
+            parts.push(`- \`${file.path}\` (${file.reason})`);
+        }
+        parts.push('');
+    }
+    // Affected Areas
+    if (context.affectedAreas.length > 0) {
+        parts.push('### Affected Areas');
+        parts.push(context.affectedAreas.join(', '));
+        parts.push('');
+    }
+    // Git Context
+    if (context.gitContext) {
+        parts.push('## Git Context');
+        parts.push(`- **Current Branch:** ${context.gitContext.currentBranch}`);
+        parts.push(`- **Working Directory Clean:** ${context.gitContext.isClean}`);
+        parts.push('');
+    }
+    // Task Instructions
+    parts.push('## Your Task');
+    parts.push('Convert the user\'s plan above into valid JSON matching this schema:');
+    parts.push('```json');
+    parts.push(IMPLEMENTATION_PLAN_SCHEMA);
+    parts.push('```');
+    parts.push('');
+    parts.push('REMEMBER:');
+    parts.push('- PRESERVE the user\'s task descriptions and order');
+    parts.push('- ADD technical details (IDs, file paths, dependencies, complexity scores)');
+    parts.push('- DO NOT add, remove, or restructure tasks');
+    parts.push('- Use project context to populate targetFiles accurately');
+    parts.push('');
+    parts.push('Respond with ONLY the JSON object, no other text.');
+    return parts.join('\n');
+}
+/**
+ * Adopts a user-provided plan by validating and enriching it with technical details.
+ * Uses PLAN_ADOPT mode - preserves user's task structure, adds IDs/files/dependencies.
+ *
+ * @param userProvidedPlan - The user's structured plan input
+ * @param context - Gathered project context
+ * @param adoptedPlanSummary - Optional summary from classification of what was detected
+ * @param toolCallId - Optional tool call ID for status updates
+ * @returns An enriched implementation plan preserving user's structure
+ */
+export async function adoptPlanWithLLM(userProvidedPlan, context, adoptedPlanSummary, toolCallId) {
+    logger.info('Adopting user-provided plan with LLM enrichment', {
+        projectType: context.projectType,
+        planLength: userProvidedPlan.length,
+        relevantFiles: context.relevantFiles.length,
+    });
+    const startTime = Date.now();
+    try {
+        // Get the Anthropic client
+        emitStatus(toolCallId, 'Initializing plan adoption...');
+        const client = await getAnthropicClient();
+        if (!client.isInitialized()) {
+            await client.initialize();
+        }
+        // Build prompts - use adoption-specific prompt
+        emitStatus(toolCallId, 'Validating user plan structure...');
+        const systemPrompt = PLAN_ADOPTION_SYSTEM_PROMPT;
+        const userPrompt = buildAdoptionUserPrompt(userProvidedPlan, context, adoptedPlanSummary);
+        // Stream the response with progress tracking
+        emitStatus(toolCallId, 'Enriching plan with technical details...');
+        const progressTracker = new PlanProgressTracker();
+        let fullContent = '';
+        // Use streaming to track progress
+        for await (const response of client.streamMessage([{ role: 'user', content: userPrompt }], {
+            system: systemPrompt,
+            maxTokens: 8192,
+            temperature: 0.3, // Lower temperature for adoption - preserve structure
+        })) {
+            if (response.type === 'text' && response.content) {
+                fullContent += response.content;
+                // Update progress based on streamed content
+                const progressMessage = progressTracker.update(response.content);
+                if (progressMessage) {
+                    emitStatus(toolCallId, progressMessage);
+                }
+            }
+            else if (response.type === 'error') {
+                throw new Error(response.error || 'Unknown streaming error');
+            }
+        }
+        logger.debug('LLM plan adoption response received', {
+            contentLength: fullContent.length,
+            summary: progressTracker.getSummary(),
+        });
+        // Parse the response
+        emitStatus(toolCallId, 'Parsing adopted plan...');
+        const parsedPlan = parsePlanResponse(fullContent);
+        // Validate and fill in missing fields
+        emitStatus(toolCallId, 'Validating plan structure...');
+        const plan = validateAndFillPlan(parsedPlan, userProvidedPlan);
+        const duration = Date.now() - startTime;
+        logger.info('Plan adopted successfully', {
+            planId: plan.id,
+            taskCount: plan.tasks.length,
+            totalComplexity: plan.totalComplexity,
+            duration: `${duration}ms`,
+        });
+        return plan;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error('Failed to adopt plan with LLM', { error: errorMessage });
+        // Return a fallback plan based on basic parsing of user input
+        return createAdoptionFallbackPlan(userProvidedPlan, context, errorMessage);
+    }
+}
+/**
+ * Creates a fallback plan when LLM adoption fails.
+ * Attempts basic parsing of user's structured input.
+ */
+function createAdoptionFallbackPlan(userProvidedPlan, context, errorReason) {
+    logger.warn('Creating adoption fallback plan due to LLM error', { errorReason });
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    // Basic extraction of numbered items from user input
+    const lines = userProvidedPlan.split('\n');
+    const tasks = [];
+    let taskOrder = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Match numbered items like "1.", "2.", "1)", "2)", "- ", "* "
+        const match = trimmed.match(/^(?:(\d+)[.)]|\s*[-*])\s*(.+)/);
+        if (match && match[2]) {
+            taskOrder++;
+            tasks.push({
+                id: `task-${uuidv4().slice(0, 8)}`,
+                order: taskOrder,
+                description: match[2].trim(),
+                targetFiles: [],
+                targetElements: [],
+                changes: match[2].trim(),
+                dependencies: taskOrder > 1 ? [`task-${tasks[tasks.length - 1]?.id || ''}`] : [],
+                verificationCriteria: ['Task completed as described'],
+                complexity: 5,
+                requirementRefs: [],
+            });
+        }
+    }
+    // If no tasks extracted, create a single task from the whole input
+    if (tasks.length === 0) {
+        tasks.push({
+            id: `task-${uuidv4().slice(0, 8)}`,
+            order: 1,
+            description: userProvidedPlan.substring(0, 200),
+            targetFiles: context.relevantFiles.slice(0, 3).map((f) => f.path),
+            targetElements: [],
+            changes: userProvidedPlan,
+            dependencies: [],
+            verificationCriteria: ['Implementation matches user specification'],
+            complexity: 5,
+            requirementRefs: [],
+        });
+    }
+    return {
+        id,
+        createdAt: now,
+        version: 1,
+        title: `Adopted Plan (${tasks.length} tasks)`,
+        problemStatement: `${userProvidedPlan.substring(0, 500)}\n\n[Note: LLM adoption failed: ${errorReason}. Tasks extracted via basic parsing.]`,
+        requirements: [
+            {
+                id: `req-${uuidv4().slice(0, 8)}`,
+                description: 'Implement user-provided plan',
+                priority: 1,
+                source: 'user',
+            },
+        ],
+        edgeCases: [],
+        constraints: [`Project type: ${context.projectType || 'unknown'}`],
+        assumptions: ['User-provided plan is complete and accurate'],
+        impact: {
+            fileOperations: [],
+            dependenciesAffected: [],
+            breakingChanges: [],
+        },
+        tasks,
+        risks: [
+            {
+                description: 'LLM plan adoption failed - tasks extracted via basic parsing',
+                severity: 'medium',
+                mitigation: 'Review extracted tasks for accuracy before proceeding',
+                rollback: 'Use git to revert changes if needed',
+            },
+        ],
+        testing: {
+            unitTests: [],
+            integrationTests: [],
+            testFiles: [],
+        },
+        rollbackStrategy: 'Use git to revert all changes',
+        totalComplexity: Math.min(tasks.length + 2, 10),
+        summary: `Adopted plan with ${tasks.length} tasks extracted from user input`,
+    };
+}
+/**
+ * Modifies an existing plan using the LLM.
+ * Preserves completed tasks and only updates affected portions.
+ *
+ * @param existingPlan - The current plan to modify
+ * @param modificationRequest - Description of what changes to make
+ * @param context - Gathered project context
+ * @param completedTaskIds - IDs of tasks already completed
+ * @param preserveCompleted - Whether to preserve completed tasks (default: true)
+ * @param toolCallId - Optional tool call ID for status updates
+ * @returns The updated implementation plan
+ */
+export async function modifyPlanWithLLM(existingPlan, modificationRequest, context, completedTaskIds, preserveCompleted = true, toolCallId, skipContextInjection = false) {
+    logger.info('Modifying existing plan with LLM', {
+        planId: existingPlan.id,
+        currentVersion: existingPlan.version,
+        completedTasks: completedTaskIds.length,
+        modificationRequest: modificationRequest.substring(0, 100),
+        skipContextInjection,
+    });
+    const startTime = Date.now();
+    try {
+        // Get the Anthropic client
+        emitStatus(toolCallId, 'Analyzing modification request...');
+        const client = await getAnthropicClient();
+        if (!client.isInitialized()) {
+            await client.initialize();
+        }
+        // Build prompts — use lightweight version when plan is already in conversation
+        const systemPrompt = PLAN_MODIFICATION_SYSTEM_PROMPT;
+        let userPrompt;
+        if (skipContextInjection) {
+            logger.info('Using lightweight plan modification prompt (skipping context re-injection)');
+            userPrompt = buildLightweightPlanModificationPrompt(existingPlan, modificationRequest, completedTaskIds, preserveCompleted);
+        }
+        else {
+            userPrompt = buildPlanModificationUserPrompt(existingPlan, modificationRequest, {
+                projectRoot: context.projectRoot,
+                projectType: context.projectType,
+                languages: context.languages,
+                directoryTree: context.directoryTree,
+                relevantFiles: context.relevantFiles.map((f) => ({ path: f.path, reason: f.reason })),
+                affectedAreas: context.affectedAreas,
+                gitContext: context.gitContext,
+            }, completedTaskIds, preserveCompleted);
+        }
+        // Stream the response with progress tracking
+        emitStatus(toolCallId, 'Generating updated plan...');
+        const progressTracker = new PlanProgressTracker();
+        let fullContent = '';
+        // Use streaming to track progress
+        for await (const response of client.streamMessage([{ role: 'user', content: userPrompt }], {
+            system: systemPrompt,
+            maxTokens: 8192,
+            temperature: 0.4, // Balanced temperature for modification
+        })) {
+            if (response.type === 'text' && response.content) {
+                fullContent += response.content;
+                // Update progress based on streamed content
+                const progressMessage = progressTracker.update(response.content);
+                if (progressMessage) {
+                    emitStatus(toolCallId, progressMessage);
+                }
+            }
+            else if (response.type === 'error') {
+                throw new Error(response.error || 'Unknown streaming error');
+            }
+        }
+        logger.debug('LLM plan modification response received', {
+            contentLength: fullContent.length,
+            summary: progressTracker.getSummary(),
+        });
+        // Parse the response
+        emitStatus(toolCallId, 'Parsing modified plan...');
+        const parsedPlan = parsePlanResponse(fullContent);
+        // Validate and fill in missing fields
+        emitStatus(toolCallId, 'Validating plan structure...');
+        const updatedPlan = validateAndFillPlan(parsedPlan, modificationRequest);
+        // Preserve original ID and increment version
+        updatedPlan.id = existingPlan.id;
+        updatedPlan.version = existingPlan.version + 1;
+        const duration = Date.now() - startTime;
+        logger.info('Plan modified successfully', {
+            planId: updatedPlan.id,
+            previousVersion: existingPlan.version,
+            newVersion: updatedPlan.version,
+            taskCount: updatedPlan.tasks.length,
+            duration: `${duration}ms`,
+        });
+        emitStatus(toolCallId, `Plan updated to version ${updatedPlan.version}`);
+        return updatedPlan;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error('Failed to modify plan with LLM', { error: errorMessage });
+        // Return original plan with error note in assumptions
+        const fallbackPlan = {
+            ...existingPlan,
+            version: existingPlan.version + 1,
+            assumptions: [
+                ...(existingPlan.assumptions || []),
+                `[MODIFICATION FAILED] ${errorMessage} - Original plan preserved`,
+            ],
+        };
+        return fallbackPlan;
+    }
+}
+//# sourceMappingURL=llm-plan-generator.js.map