maistro 1.0.390

package/dist/planner.js

@@ -0,0 +1,830 @@
+import { execa } from 'execa';
+import { createTask, DEFAULT_CONFIG } from './types.js';
+import { extractImagePlaceholders } from './imageManager.js';
+import { getClaudePath } from './claudePath.js';
+/**
+ * Call Claude Code CLI with a prompt and return the response
+ * Supports optional streaming output via onOutput callback
+ */
+async function callClaudeCode(prompt, cwd, onOutput, abortSignal) {
+    // Exclude ANTHROPIC_API_KEY to use subscription auth
+    const { ANTHROPIC_API_KEY: _excluded, ...cleanEnv } = process.env;
+    try {
+        // Use streaming JSON output if onOutput callback provided
+        // Note: --output-format stream-json requires --verbose when used with --print
+        const args = onOutput
+            ? ['--print', '--verbose', '--output-format', 'stream-json', '-p', prompt]
+            : ['--print', '-p', prompt];
+        const subprocess = execa(getClaudePath(), args, {
+            cwd: cwd || process.cwd(),
+            timeout: 600000, // 10 minutes for planning (long prompts may need time)
+            reject: false,
+            stdin: 'ignore',
+            stdout: 'pipe',
+            stderr: 'pipe',
+            buffer: !onOutput, // Disable buffering for streaming
+            env: cleanEnv,
+            cancelSignal: abortSignal,
+        });
+        let stdout = '';
+        let stderr = '';
+        let lineBuffer = '';
+        // Stream stdout if callback provided
+        if (onOutput && subprocess.stdout) {
+            subprocess.stdout.on('data', (chunk) => {
+                const text = chunk.toString();
+                stdout += text;
+                // Process line by line
+                lineBuffer += text;
+                const lines = lineBuffer.split('\n');
+                lineBuffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const parsed = JSON.parse(line);
+                        // Handle stream-json format - extract text content
+                        if (parsed.type === 'assistant' && parsed.message?.content) {
+                            for (const block of parsed.message.content) {
+                                if (block.type === 'text' && block.text) {
+                                    onOutput(block.text);
+                                }
+                            }
+                        }
+                        else if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
+                            onOutput(parsed.delta.text);
+                        }
+                    }
+                    catch {
+                        // Not JSON, output raw line
+                        onOutput(line);
+                    }
+                }
+            });
+        }
+        if (subprocess.stderr) {
+            subprocess.stderr.on('data', (chunk) => {
+                stderr += chunk.toString();
+            });
+        }
+        const result = await subprocess;
+        // If not streaming, get stdout from result
+        if (!onOutput) {
+            stdout = typeof result.stdout === 'string' ? result.stdout : '';
+            stderr = typeof result.stderr === 'string' ? result.stderr : '';
+        }
+        if (result.exitCode !== 0) {
+            // Provide user-friendly error messages for common exit codes
+            let errorMsg = stderr || `Claude Code exited with code ${result.exitCode}`;
+            if (result.exitCode === 143) {
+                // SIGTERM (128 + 15) - process was terminated
+                // Check if this was an intentional abort via the abort signal
+                if (abortSignal?.aborted) {
+                    return {
+                        success: false,
+                        response: '',
+                        error: 'Request cancelled',
+                        aborted: true,
+                    };
+                }
+                // Otherwise it was a timeout or external termination
+                errorMsg = 'Request timed out or was interrupted. Try breaking your request into smaller parts.';
+            }
+            else if (result.exitCode === 137) {
+                // SIGKILL (128 + 9) - process was killed, possibly OOM
+                errorMsg = 'Process was killed (possibly out of memory). Try a simpler request.';
+            }
+            else if (result.exitCode === 1 && stderr.includes('rate limit')) {
+                errorMsg = 'Rate limit reached. Please wait a moment and try again.';
+            }
+            return {
+                success: false,
+                response: '',
+                error: errorMsg,
+            };
+        }
+        // For streaming, extract the final result from the accumulated JSON
+        let finalResponse = stdout.trim();
+        if (onOutput) {
+            // Parse the accumulated output to get the final text
+            const textParts = [];
+            for (const line of stdout.split('\n')) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.type === 'result' && parsed.result) {
+                        finalResponse = parsed.result;
+                        break;
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+            if (!finalResponse || finalResponse === stdout.trim()) {
+                // Fallback: try to extract text from content blocks
+                for (const line of stdout.split('\n')) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const parsed = JSON.parse(line);
+                        if (parsed.type === 'assistant' && parsed.message?.content) {
+                            for (const block of parsed.message.content) {
+                                if (block.type === 'text' && block.text) {
+                                    textParts.push(block.text);
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+                if (textParts.length > 0) {
+                    finalResponse = textParts.join('');
+                }
+            }
+        }
+        return {
+            success: true,
+            response: finalResponse,
+        };
+    }
+    catch (error) {
+        // Check if this was an abort
+        const isAborted = error instanceof Error && (error.name === 'AbortError' ||
+            error.message.includes('aborted') ||
+            error.message.includes('canceled') ||
+            error.code === 'ERR_CANCELED');
+        if (isAborted) {
+            return {
+                success: false,
+                response: '',
+                error: 'Request cancelled',
+                aborted: true,
+            };
+        }
+        return {
+            success: false,
+            response: '',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+const DECOMPOSITION_PROMPT = `You are a project planning assistant. Your job is to break down a project goal into a series of small, atomic tasks that can be executed sequentially by an AI coding assistant (Claude Code).
+
+Guidelines for task decomposition:
+1. Each task should be completable in a single coding session (10-30 minutes)
+2. Tasks should be ordered by dependency (tasks that depend on others come later)
+3. Each task should have a clear, specific objective
+4. Include setup tasks if needed (e.g., "Initialize project structure")
+5. Include testing tasks where appropriate
+6. Be specific about what files or components are involved
+7. Consider which tasks are critical vs optional - critical tasks should stop execution if they fail
+8. IMPORTANT: Each task MUST have clear, verifiable acceptance criteria
+
+## Acceptance Criteria Guidelines - CRITICAL
+
+Generate OUTCOME-BASED criteria, not structural criteria. Focus on WHAT should work, not HOW it should be implemented.
+
+GOOD (outcome-based, flexible):
+- "App can persist data locally and retrieve it after restart"
+- "User can view entries filtered by date range"
+- "Form validates required fields and shows error messages"
+- "API endpoint returns user data in JSON format"
+- "Project builds without errors"
+
+AVOID (structural, fragile):
+- "DataPersistenceService.swift exists in Services/ folder"
+- "Uses @Model macro for SwiftData"
+- "fetchByDateRange() method accepts two Date parameters"
+- "modelContainer property exists on the service class"
+
+WHY: Implementation details may change during development as the AI finds better approaches.
+Outcome-based criteria allow flexibility while ensuring the desired functionality works.
+
+Only use structural criteria when the structure itself IS the requirement (e.g., "Uses SwiftData" if iOS 17+ SwiftData is a hard requirement from the user).
+
+For each task, provide:
+- id: A unique identifier (e.g., "task-1", "task-2")
+- title: A short, descriptive title
+- description: Detailed instructions for what needs to be done
+- acceptanceCriteria: Array of 2-4 short, specific, OUTCOME-BASED conditions. Each criterion should:
+  - Focus on observable behavior or testable functionality
+  - Be verifiable by running the app or tests (not by inspecting code structure)
+  - Avoid specifying exact file names, class names, or method signatures
+- dependencies: Array of task IDs that must complete before this task (empty for first tasks)
+- contextPatterns: Glob patterns for files relevant to this task (e.g., ["src/**/*.ts", "package.json"])
+- ifFailed: What to do if this task fails after retries. IMPORTANT: Default is "skip"
+  - "skip" (DEFAULT - use this unless there's a specific reason not to): Skip this task and continue with others
+  - "stop": Stop execution entirely - ONLY use for truly critical tasks where nothing else can proceed
+  - "retry": Keep retrying indefinitely (use sparingly)
+
+Respond with a JSON array of tasks. Example format:
+[
+  {
+    "id": "task-1",
+    "title": "Initialize project structure",
+    "description": "Create the basic project structure with package.json, tsconfig.json, and src directory",
+    "acceptanceCriteria": [
+      "Project can be installed with npm install",
+      "TypeScript compilation succeeds with strict mode",
+      "Project structure follows standard conventions"
+    ],
+    "dependencies": [],
+    "contextPatterns": ["package.json", "tsconfig.json"],
+    "ifFailed": "skip"
+  },
+  {
+    "id": "task-2",
+    "title": "Implement user model",
+    "description": "Create a User type and model with fields for id, name, email. The model should be exportable for use in other modules.",
+    "acceptanceCriteria": [
+      "User type can be imported from the models module",
+      "User objects can be created with id, name, and email fields",
+      "TypeScript provides proper type checking for User objects"
+    ],
+    "dependencies": ["task-1"],
+    "contextPatterns": ["src/models/**/*.ts"],
+    "ifFailed": "skip"
+  }
+]
+
+IMPORTANT: Return ONLY the JSON array, no other text or markdown formatting.`;
+const DISCOVERY_PROMPT = `You are helping plan a software project. Analyze the user's goal and generate clarifying questions to understand their requirements better.
+
+Your task is to:
+1. Briefly summarize what you understand the user wants to build
+2. Generate 2-4 targeted questions about key decisions that will affect the implementation
+3. List assumptions you're making that might need confirmation
+
+Focus questions on:
+- Technology preferences (frameworks, languages, databases)
+- Scope clarification (MVP features vs full feature set)
+- Architecture decisions (monolith vs services, deployment target)
+- Integration requirements (external APIs, existing systems)
+
+Return your response as JSON in this exact format:
+{
+  "summary": "Brief description of what the user wants to build",
+  "questions": [
+    {
+      "id": "tech-stack",
+      "question": "What tech stack would you prefer?",
+      "type": "choice",
+      "options": ["Option 1 (Recommended)", "Option 2", "Option 3", "Other"],
+      "default": "Option 1 (Recommended)",
+      "reason": "Why this question matters for the project"
+    }
+  ],
+  "assumptions": [
+    "Assumption 1 that can be confirmed or corrected",
+    "Assumption 2"
+  ]
+}
+
+Question types:
+- "choice": Single selection from options (most common)
+- "text": Free-form text input
+- "multi-choice": Multiple selections allowed
+
+Guidelines:
+- Keep questions actionable and relevant to implementation
+- Provide sensible defaults where possible
+- Mark recommended options with "(Recommended)"
+- Limit to 2-4 questions to avoid fatigue
+- Keep the summary concise (1-2 sentences)
+
+IMPORTANT: Return ONLY the JSON object, no other text or markdown formatting.`;
+/**
+ * Analyze a project goal and generate discovery questions
+ */
+export async function discoverRequirements(goal, options = {}) {
+    const fullPrompt = `${DISCOVERY_PROMPT}\n\nProject Goal: ${goal}`;
+    const result = await callClaudeCode(fullPrompt, options.cwd, options.onOutput);
+    if (!result.success) {
+        return {
+            success: false,
+            summary: '',
+            questions: [],
+            assumptions: [],
+            error: result.error || 'Claude Code CLI failed',
+        };
+    }
+    const rawResponse = result.response;
+    // Parse JSON response
+    try {
+        // Try to extract JSON object from the response
+        const jsonMatch = rawResponse.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            return {
+                success: false,
+                summary: '',
+                questions: [],
+                assumptions: [],
+                error: 'No JSON object found in response',
+                rawResponse,
+            };
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        // Validate required fields
+        if (!parsed.summary || !Array.isArray(parsed.questions)) {
+            return {
+                success: false,
+                summary: '',
+                questions: [],
+                assumptions: [],
+                error: 'Invalid response format: missing summary or questions',
+                rawResponse,
+            };
+        }
+        // Validate and normalize questions
+        const questions = parsed.questions.map((q, index) => ({
+            id: q.id || `question-${index + 1}`,
+            question: q.question || 'Unknown question',
+            type: (q.type === 'text' || q.type === 'multi-choice') ? q.type : 'choice',
+            options: q.options || [],
+            default: q.default,
+            reason: q.reason,
+        }));
+        return {
+            success: true,
+            summary: parsed.summary,
+            questions,
+            assumptions: Array.isArray(parsed.assumptions) ? parsed.assumptions : [],
+            rawResponse,
+        };
+    }
+    catch (parseError) {
+        return {
+            success: false,
+            summary: '',
+            questions: [],
+            assumptions: [],
+            error: `Failed to parse JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+            rawResponse,
+        };
+    }
+}
+/**
+ * Build project context from discovery results for decomposition
+ */
+export function buildProjectContext(goal, discoveryResult) {
+    return {
+        goal,
+        summary: discoveryResult.summary,
+        preferences: discoveryResult.answers,
+        assumptions: discoveryResult.assumptions,
+    };
+}
+/**
+ * Format project context as a string for the decomposition prompt
+ */
+export function formatContextForDecomposition(context) {
+    const parts = [];
+    if (context.summary) {
+        parts.push(`Project Summary: ${context.summary}`);
+    }
+    if (Object.keys(context.preferences).length > 0) {
+        parts.push('\nUser Preferences:');
+        for (const [key, value] of Object.entries(context.preferences)) {
+            parts.push(`- ${key}: ${value}`);
+        }
+    }
+    if (context.assumptions.length > 0) {
+        parts.push('\nConfirmed Assumptions:');
+        for (const assumption of context.assumptions) {
+            parts.push(`- ${assumption}`);
+        }
+    }
+    return parts.join('\n');
+}
+/** Reserved ID for the finalize task */
+export const FINALIZE_TASK_ID = 'task-finalize';
+/**
+ * Create a finalize task that depends on all existing tasks
+ * This task runs last and updates CLAUDE.md with project knowledge
+ */
+function createFinalizeTask(existingTasks) {
+    const allTaskIds = existingTasks.map(t => t.id);
+    return createTask({
+        id: FINALIZE_TASK_ID,
+        title: 'Finalize project and update documentation',
+        description: `Complete the project with cleanup and documentation:
+
+1. **Cleanup Tasks:**
+   - Remove any temporary files, debug logs, or test artifacts created during development
+   - Clean up any commented-out code or TODO markers that are no longer relevant
+   - Ensure no sensitive data (API keys, credentials) is left in the codebase
+
+2. **Update CLAUDE.md Documentation:**
+   Read the existing CLAUDE.md (if present) and update it with:
+   - Project overview and purpose
+   - Architecture summary (key modules, their responsibilities, and how they interact)
+   - Build and development commands (install, build, test, run)
+   - Key design patterns and conventions used in this codebase
+   - Important file locations and their purposes
+   - Any gotchas or non-obvious behavior future developers should know
+
+   If CLAUDE.md does not exist, create it with the above sections.
+
+3. **Verification:**
+   - Ensure the project builds successfully
+   - Ensure tests pass (if applicable)
+   - Review that documentation accurately reflects the implemented code`,
+        dependencies: allTaskIds,
+        contextPatterns: ['CLAUDE.md', 'README.md', 'package.json', 'tsconfig.json', 'src/**/*.ts', 'src/**/*.tsx', 'src/**/*.js', '*.config.js', '*.config.ts'],
+        ifFailed: 'skip', // Non-critical - don't block if this fails
+        maxRetries: 2, // Fewer retries since it's a documentation task
+    });
+}
+/**
+ * Decompose a project goal into tasks using Claude Code CLI
+ */
+export async function decompose(goal, projectContext = '', options = {}) {
+    const userMessage = projectContext
+        ? `Project Goal: ${goal}\n\nExisting Project Context:\n${projectContext}`
+        : `Project Goal: ${goal}`;
+    const fullPrompt = `${DECOMPOSITION_PROMPT}\n\n${userMessage}`;
+    const result = await callClaudeCode(fullPrompt, options.cwd);
+    if (!result.success) {
+        return {
+            success: false,
+            tasks: [],
+            error: result.error || 'Claude Code CLI failed',
+        };
+    }
+    const rawResponse = result.response;
+    // Parse JSON response
+    let parsedTasks;
+    try {
+        // Try to extract JSON from the response (in case there's extra text)
+        const jsonMatch = rawResponse.match(/\[[\s\S]*\]/);
+        if (!jsonMatch) {
+            return {
+                success: false,
+                tasks: [],
+                error: 'No JSON array found in response',
+                rawResponse,
+            };
+        }
+        parsedTasks = JSON.parse(jsonMatch[0]);
+    }
+    catch (parseError) {
+        return {
+            success: false,
+            tasks: [],
+            error: `Failed to parse JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+            rawResponse,
+        };
+    }
+    // Validate and convert to Task objects
+    if (!Array.isArray(parsedTasks)) {
+        return {
+            success: false,
+            tasks: [],
+            error: 'Response is not an array',
+            rawResponse,
+        };
+    }
+    const tasks = parsedTasks.map(pt => {
+        // Validate and normalize ifFailed value
+        const validFailureActions = ['retry', 'skip', 'stop'];
+        const ifFailed = validFailureActions.includes(pt.ifFailed)
+            ? pt.ifFailed
+            : DEFAULT_CONFIG.defaultIfFailed;
+        const description = pt.description || '';
+        // Extract image references from description
+        const imageRefs = extractImagePlaceholders(description);
+        return createTask({
+            id: pt.id || `task-${Math.random().toString(36).slice(2, 8)}`,
+            title: pt.title || 'Untitled Task',
+            description,
+            acceptanceCriteria: pt.acceptanceCriteria,
+            dependencies: pt.dependencies || [],
+            contextPatterns: pt.contextPatterns || [],
+            testCommand: pt.testCommand,
+            ifFailed,
+            timeout: pt.timeout ?? DEFAULT_CONFIG.executionTimeout,
+            maxRetries: pt.maxRetries ?? DEFAULT_CONFIG.maxRetries,
+            imageRefs: imageRefs.length > 0 ? imageRefs : undefined,
+        });
+    });
+    // Append finalize task if there are tasks to finalize
+    if (tasks.length > 0) {
+        tasks.push(createFinalizeTask(tasks));
+    }
+    return {
+        success: true,
+        tasks,
+        rawResponse,
+    };
+}
+/**
+ * Validate that task dependencies form a valid DAG (no cycles)
+ */
+export function validateTaskDependencies(tasks) {
+    const taskIds = new Set(tasks.map(t => t.id));
+    // Check all dependencies reference existing tasks
+    for (const task of tasks) {
+        for (const depId of task.dependencies) {
+            if (!taskIds.has(depId)) {
+                return {
+                    valid: false,
+                    error: `Task "${task.id}" depends on non-existent task "${depId}"`,
+                };
+            }
+        }
+    }
+    // Check for cycles using DFS
+    const visited = new Set();
+    const recursionStack = new Set();
+    function hasCycle(taskId) {
+        visited.add(taskId);
+        recursionStack.add(taskId);
+        const task = tasks.find(t => t.id === taskId);
+        if (task) {
+            for (const depId of task.dependencies) {
+                if (!visited.has(depId)) {
+                    if (hasCycle(depId)) {
+                        return true;
+                    }
+                }
+                else if (recursionStack.has(depId)) {
+                    return true;
+                }
+            }
+        }
+        recursionStack.delete(taskId);
+        return false;
+    }
+    for (const task of tasks) {
+        if (!visited.has(task.id)) {
+            if (hasCycle(task.id)) {
+                return {
+                    valid: false,
+                    error: 'Circular dependency detected in tasks',
+                };
+            }
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Sort tasks topologically based on dependencies
+ */
+export function sortTasksByDependency(tasks) {
+    const sorted = [];
+    const visited = new Set();
+    const taskMap = new Map(tasks.map(t => [t.id, t]));
+    function visit(taskId) {
+        if (visited.has(taskId))
+            return;
+        visited.add(taskId);
+        const task = taskMap.get(taskId);
+        if (task) {
+            for (const depId of task.dependencies) {
+                visit(depId);
+            }
+            sorted.push(task);
+        }
+    }
+    for (const task of tasks) {
+        visit(task.id);
+    }
+    return sorted;
+}
+const PLAN_REFINEMENT_PROMPT = `You are a PLANNING assistant modifying a task plan. This is PLANNING MODE - you must NEVER execute actions.
+
+CRITICAL: When the user says things like "run tests", "add feature X", "fix bug Y", or ANY action-sounding request, you must:
+1. Create a TASK that describes this work
+2. Return it as JSON so it can be ADDED TO THE PLAN
+3. NEVER actually execute the action yourself
+
+DO NOT:
+- Run any commands or tools
+- Read files or explore code
+- Execute tests or builds
+- Make any changes to the codebase
+
+ONLY:
+- Return new/modified tasks as JSON
+- Discuss the plan with the user
+
+Project: {PROJECT_NAME}
+Goal summary: {GOAL_SUMMARY}
+Progress: {COMPLETED_COUNT} completed, {PENDING_COUNT} pending
+
+{COMPLETED_SECTION}
+{PENDING_SECTION}
+
+RULES:
+- Return ONLY the tasks you're adding/modifying as a JSON array in a code block
+- Use existing task IDs when modifying, new IDs (e.g., "task-{NEXT_ID}") when adding
+- NEVER return completed tasks - they are preserved automatically
+- Omit "status" field - system handles it
+- Keep responses brief
+
+Example: If user says "run ui tests", return:
+\`\`\`json
+[{"id": "task-{NEXT_ID}", "title": "Run UI tests", "description": "Execute the UI test suite to verify functionality"}]
+\`\`\``;
+/**
+ * Refine a plan through conversation with the user
+ */
+export async function refinePlan(goal, currentTasks, userMessage, conversationHistory, options = {}) {
+    // Separate completed and pending tasks for compact context
+    const completedTasks = currentTasks.filter(t => t.status === 'completed' || t.status === 'skipped');
+    const pendingTasks = currentTasks.filter(t => t.status === 'pending' || t.status === 'in_progress' || t.status === 'failed');
+    // Calculate next task ID for the prompt
+    const maxTaskNum = currentTasks.reduce((max, t) => {
+        const match = t.id.match(/task-(\d+)/);
+        return match ? Math.max(max, parseInt(match[1], 10)) : max;
+    }, 0);
+    const nextId = maxTaskNum + 1;
+    // Compact format for completed tasks (just id and title)
+    const completedSection = completedTasks.length > 0
+        ? `Completed tasks (${completedTasks.length}):\n${completedTasks.map(t => `- ${t.id}: ${t.title}`).join('\n')}`
+        : '';
+    // Full format for pending tasks (they may need modification)
+    const pendingSection = pendingTasks.length > 0
+        ? `Pending tasks:\n\`\`\`json\n${JSON.stringify(pendingTasks.map(t => ({
+            id: t.id,
+            title: t.title,
+            description: t.description,
+            acceptanceCriteria: t.acceptanceCriteria,
+            dependencies: t.dependencies,
+            status: t.status,
+        })), null, 2)}\n\`\`\``
+        : 'No pending tasks.';
+    // Truncate goal if too long (keep first 500 chars as summary)
+    const goalSummary = goal.length > 500
+        ? goal.slice(0, 500) + '...'
+        : goal;
+    // Extract project name from goal (first line or first sentence)
+    const projectName = goal.split(/[.\n]/)[0].slice(0, 100);
+    const systemPrompt = PLAN_REFINEMENT_PROMPT
+        .replace('{PROJECT_NAME}', projectName)
+        .replace('{GOAL_SUMMARY}', goalSummary)
+        .replace('{COMPLETED_COUNT}', String(completedTasks.length))
+        .replace('{PENDING_COUNT}', String(pendingTasks.length))
+        .replace('{COMPLETED_SECTION}', completedSection)
+        .replace('{PENDING_SECTION}', pendingSection)
+        .replace('{NEXT_ID}', String(nextId));
+    // Build conversation context for CLI (only last few exchanges to save tokens)
+    const recentHistory = conversationHistory.slice(-4); // Keep last 2 exchanges
+    const historyContext = recentHistory.length > 0
+        ? '\n\nRecent conversation:\n' + recentHistory.map(m => `${m.role}: ${m.content}`).join('\n')
+        : '';
+    const fullPrompt = `${systemPrompt}${historyContext}\n\nUser: ${userMessage}`;
+    const result = await callClaudeCode(fullPrompt, options.cwd, options.onOutput, options.abortSignal);
+    if (!result.success) {
+        return {
+            success: false,
+            response: '',
+            error: result.error || 'Claude Code CLI failed',
+            aborted: result.aborted,
+        };
+    }
+    const responseText = result.response;
+    // Check if the response contains a new task list
+    const jsonMatch = responseText.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
+    if (jsonMatch) {
+        try {
+            const parsedTasks = JSON.parse(jsonMatch[1]);
+            // Create a map of existing tasks for merging
+            const existingTaskMap = new Map(currentTasks.map(t => [t.id, t]));
+            const modifiedTaskIds = new Set();
+            // Process returned tasks (new or modified only)
+            const processedTasks = parsedTasks.map((pt) => {
+                const taskId = pt.id || `task-${Math.random().toString(36).slice(2, 8)}`;
+                modifiedTaskIds.add(taskId);
+                const existingTask = existingTaskMap.get(taskId);
+                // Validate and normalize ifFailed value
+                const validFailureActions = ['retry', 'skip', 'stop'];
+                const ifFailed = validFailureActions.includes(pt.ifFailed)
+                    ? pt.ifFailed
+                    : (existingTask?.ifFailed ?? DEFAULT_CONFIG.defaultIfFailed);
+                const description = pt.description || existingTask?.description || '';
+                // Extract image references from description
+                const imageRefs = extractImagePlaceholders(description);
+                // If task already exists, update it
+                if (existingTask) {
+                    // Allow status change to 'pending' for retry (clears error state)
+                    const shouldResetStatus = pt.status === 'pending' && existingTask.status !== 'pending';
+                    const updatedTask = {
+                        ...existingTask,
+                        title: pt.title || existingTask.title,
+                        description,
+                        // Use ?? instead of || so empty arrays are preserved (not treated as falsy)
+                        acceptanceCriteria: pt.acceptanceCriteria ?? existingTask.acceptanceCriteria,
+                        dependencies: pt.dependencies ?? existingTask.dependencies,
+                        contextPatterns: pt.contextPatterns ?? existingTask.contextPatterns,
+                        testCommand: pt.testCommand ?? existingTask.testCommand,
+                        ifFailed,
+                        timeout: pt.timeout ?? existingTask.timeout,
+                        maxRetries: pt.maxRetries ?? existingTask.maxRetries,
+                        imageRefs: imageRefs.length > 0 ? imageRefs : existingTask.imageRefs,
+                        updatedAt: new Date().toISOString(),
+                    };
+                    // Reset task to pending if Claude explicitly requested it
+                    if (shouldResetStatus) {
+                        updatedTask.status = 'pending';
+                        updatedTask.retryCount = 0;
+                        updatedTask.error = undefined;
+                        updatedTask.failureType = undefined;
+                    }
+                    return updatedTask;
+                }
+                // New task - create with default status
+                return createTask({
+                    id: taskId,
+                    title: pt.title || 'Untitled Task',
+                    description,
+                    acceptanceCriteria: pt.acceptanceCriteria,
+                    dependencies: pt.dependencies || [],
+                    contextPatterns: pt.contextPatterns || [],
+                    testCommand: pt.testCommand,
+                    ifFailed,
+                    timeout: pt.timeout ?? DEFAULT_CONFIG.executionTimeout,
+                    maxRetries: pt.maxRetries ?? DEFAULT_CONFIG.maxRetries,
+                    imageRefs: imageRefs.length > 0 ? imageRefs : undefined,
+                });
+            });
+            // Merge: keep all existing tasks that weren't modified, then add/update modified ones
+            const unchangedTasks = currentTasks.filter(t => !modifiedTaskIds.has(t.id) && t.id !== FINALIZE_TASK_ID);
+            const tasks = [...unchangedTasks, ...processedTasks];
+            // Handle finalize task: ensure it exists and has correct dependencies
+            const nonFinalizeTasks = tasks.filter(t => t.id !== FINALIZE_TASK_ID);
+            const existingFinalizeTask = currentTasks.find(t => t.id === FINALIZE_TASK_ID);
+            if (nonFinalizeTasks.length > 0) {
+                if (existingFinalizeTask) {
+                    // Update finalize task dependencies to include all other tasks
+                    const updatedFinalizeTask = {
+                        ...existingFinalizeTask,
+                        dependencies: nonFinalizeTasks.map(t => t.id),
+                        status: 'pending',
+                        updatedAt: new Date().toISOString(),
+                    };
+                    tasks.push(updatedFinalizeTask);
+                }
+                else {
+                    // Re-add finalize task if it was removed
+                    tasks.push(createFinalizeTask(nonFinalizeTasks));
+                }
+            }
+            return {
+                success: true,
+                response: responseText,
+                updatedTasks: tasks,
+            };
+        }
+        catch {
+            // JSON parsing failed, just return the response text
+        }
+    }
+    return {
+        success: true,
+        response: responseText,
+    };
+}
+const README_GENERATION_PROMPT = `You are a technical documentation assistant. Generate a README.md file for a new project.
+
+The README should include:
+1. Project title and description
+2. High-level architecture overview
+3. Components/modules that will be built
+4. Technology stack (inferred from the goal and tasks)
+5. Getting started placeholder section
+
+Use proper markdown formatting. Keep it concise but informative.
+
+IMPORTANT: Return ONLY the markdown content, no code blocks wrapping it.`;
+/**
+ * Generate a README.md content based on the project goal and tasks
+ */
+export async function generateReadme(projectName, goal, tasks, options = {}) {
+    const taskList = tasks.map((t, i) => `${i + 1}. ${t.title}: ${t.description}`).join('\n');
+    const userMessage = `Project Name: ${projectName}
+Project Goal: ${goal}
+
+Planned Tasks:
+${taskList}`;
+    const fullPrompt = `${README_GENERATION_PROMPT}\n\n${userMessage}`;
+    const result = await callClaudeCode(fullPrompt, options.cwd);
+    if (!result.success) {
+        return {
+            success: false,
+            content: '',
+            error: result.error || 'Claude Code CLI failed',
+        };
+    }
+    return {
+        success: true,
+        content: result.response,
+    };
+}
+// Re-export dependency detection for use during discovery phase
+export { detectDependencies } from './dependencyDetector.js';
+//# sourceMappingURL=planner.js.map