@compass-ai/nova 1.0.74 → 1.0.75

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

@@ -1,863 +0,0 @@
-/**
- * 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