@staticpayload/zai-code 1.4.12 → 1.5.1

package/dist/orchestrator.js

@@ -39,15 +39,109 @@ const session_1 = require("./session");
 const ui_1 = require("./ui");
 const runtime_1 = require("./runtime");
 const auth_1 = require("./auth");
-const mode_prompts_1 = require("./mode_prompts");
 const apply_1 = require("./apply");
-// Helper to extract meaningful text from API response
+// Analyze task to determine best execution strategy
+function analyzeTask(input) {
+    const lower = input.toLowerCase().trim();
+    const words = lower.split(/\s+/);
+    const wordCount = words.length;
+    // CHAT - greetings, small talk
+    const chatPatterns = [
+        /^h+i+!*$/i, /^he+y+!*$/i, /^y+o+!*$/i,
+        /^(hello|hola|howdy|greetings|sup|wassup)[\s!.,]*$/i,
+        /^(good\s*(morning|afternoon|evening|night))[\s!.,]*$/i,
+        /^(what'?s?\s*up|how\s*are\s*you)[\s!?.,]*$/i,
+        /^(thanks|thank\s*you|thx|ty|bye|goodbye|ok|okay|sure|yes|no|yep|nope|yeah|nah|cool|nice|great|awesome|lol)[\s!.,]*$/i,
+    ];
+    if (chatPatterns.some(p => p.test(lower)) || (wordCount <= 3 && !lower.includes('create') && !lower.includes('make') && !lower.includes('add'))) {
+        return { type: 'chat', complexity: 'trivial', needsPlan: false, confidence: 0.95, keywords: [] };
+    }
+    // QUESTION - explicit questions
+    const questionPatterns = [
+        /^(what|why|how|when|where|who|which|explain|clarify|describe|tell me|show me)/i,
+        /\?$/,
+        /^(is|are|can|could|would|should|do|does|did|has|have|will)\s/i,
+    ];
+    if (questionPatterns.some(p => p.test(lower))) {
+        return { type: 'question', complexity: 'simple', needsPlan: false, confidence: 0.9, keywords: [] };
+    }
+    // Extract action keywords
+    const actionKeywords = {
+        create: ['create', 'make', 'new', 'add', 'generate', 'build', 'write', 'init', 'setup', 'scaffold'],
+        modify: ['update', 'change', 'modify', 'edit', 'fix', 'improve', 'enhance', 'refactor', 'rename', 'move'],
+        delete: ['delete', 'remove', 'clean', 'clear', 'drop'],
+        debug: ['fix', 'debug', 'error', 'bug', 'issue', 'broken', 'failing', 'crash', 'problem', 'wrong', 'not working'],
+        refactor: ['refactor', 'reorganize', 'restructure', 'extract', 'split', 'merge', 'consolidate', 'simplify', 'clean up'],
+    };
+    const foundKeywords = [];
+    let taskType = 'simple_edit';
+    for (const [category, keywords] of Object.entries(actionKeywords)) {
+        for (const kw of keywords) {
+            if (lower.includes(kw)) {
+                foundKeywords.push(kw);
+                if (category === 'debug')
+                    taskType = 'debug';
+                else if (category === 'refactor')
+                    taskType = 'refactor';
+            }
+        }
+    }
+    // Complexity indicators
+    const complexityIndicators = {
+        simple: ['file', 'function', 'variable', 'class', 'method', 'component', 'test', 'readme', 'config'],
+        medium: ['feature', 'module', 'service', 'api', 'endpoint', 'page', 'route', 'handler', 'middleware'],
+        complex: ['system', 'architecture', 'database', 'migration', 'integration', 'authentication', 'authorization', 'deployment', 'infrastructure', 'full', 'complete', 'entire', 'whole', 'all'],
+    };
+    let complexity = 'simple';
+    // Check for complexity indicators
+    for (const kw of complexityIndicators.complex) {
+        if (lower.includes(kw)) {
+            complexity = 'complex';
+            break;
+        }
+    }
+    if (complexity === 'simple') {
+        for (const kw of complexityIndicators.medium) {
+            if (lower.includes(kw)) {
+                complexity = 'medium';
+                break;
+            }
+        }
+    }
+    // Word count affects complexity
+    if (wordCount > 30)
+        complexity = 'complex';
+    else if (wordCount > 15 && complexity === 'simple')
+        complexity = 'medium';
+    // Multiple files mentioned = more complex
+    const filePatterns = /\.(ts|js|py|rs|go|java|cpp|c|h|css|html|json|yaml|yml|md|txt|sql|sh|bash|zsh)/gi;
+    const fileMatches = lower.match(filePatterns);
+    if (fileMatches && fileMatches.length > 2) {
+        complexity = complexity === 'simple' ? 'medium' : 'complex';
+    }
+    // "and" chains indicate complexity
+    const andCount = (lower.match(/\band\b/g) || []).length;
+    if (andCount >= 2) {
+        complexity = complexity === 'simple' ? 'medium' : 'complex';
+        taskType = 'complex_task';
+    }
+    // Determine if plan is needed
+    const needsPlan = complexity === 'complex' || (complexity === 'medium' && wordCount > 20);
+    return {
+        type: taskType,
+        complexity,
+        needsPlan,
+        confidence: foundKeywords.length > 0 ? 0.85 : 0.7,
+        keywords: foundKeywords,
+    };
+}
+// ============================================================================
+// RESPONSE PARSING
+// ============================================================================
 function extractTextFromResponse(response) {
     if (typeof response === 'string') {
-        // Strip markdown code blocks
         let text = response;
         text = text.replace(/```json\n?/gi, '').replace(/```\n?/g, '');
-        // Try to parse as JSON and extract explanation
         try {
             const parsed = JSON.parse(text);
             if (parsed.explanation)
@@ -56,14 +150,8 @@ function extractTextFromResponse(response) {
                 return parsed.output;
             if (parsed.message)
                 return parsed.message;
-            if (parsed.summary)
-                return parsed.summary;
-            if (parsed.status === 'error' && parsed.explanation)
-                return parsed.explanation;
-        }
-        catch {
-            // Not JSON, return as-is
         }
+        catch { }
         return text.trim();
     }
     if (typeof response === 'object' && response !== null) {
@@ -74,497 +162,304 @@ function extractTextFromResponse(response) {
             return String(obj.output);
         if (obj.message)
             return String(obj.message);
-        if (obj.summary)
-            return String(obj.summary);
         return JSON.stringify(response, null, 2);
     }
     return String(response);
 }
-// Try to parse file operations from response
 function parseFileOperations(response) {
     if (typeof response === 'string') {
         let text = response.trim();
-        // Try to extract JSON from markdown code blocks (handle various formats)
         const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-        if (jsonMatch) {
+        if (jsonMatch)
             text = jsonMatch[1].trim();
-        }
-        // Also try to find raw JSON object
         if (!text.startsWith('{')) {
             const jsonStart = text.indexOf('{');
             const jsonEnd = text.lastIndexOf('}');
-            if (jsonStart !== -1 && jsonEnd !== -1 && jsonEnd > jsonStart) {
+            if (jsonStart !== -1 && jsonEnd > jsonStart) {
                 text = text.substring(jsonStart, jsonEnd + 1);
             }
         }
         try {
             const parsed = JSON.parse(text);
-            if (parsed.files && Array.isArray(parsed.files)) {
+            if (parsed.files && Array.isArray(parsed.files))
                 return parsed;
-            }
-            if (parsed.status) {
+            if (parsed.status)
                 return parsed;
-            }
-        }
-        catch (e) {
-            // JSON parse failed - try to be more lenient
-            // Sometimes the API returns malformed JSON with extra text
-            console.log((0, ui_1.dim)('Note: Could not parse response as JSON'));
         }
+        catch { }
     }
     if (typeof response === 'object' && response !== null) {
         const obj = response;
-        if (obj.files && Array.isArray(obj.files)) {
+        if (obj.files && Array.isArray(obj.files))
             return obj;
-        }
-        if (obj.status) {
+        if (obj.status)
             return obj;
-        }
     }
     return null;
 }
-// Check if input is casual chat (greetings, small talk)
-function isCasualChat(input) {
-    const lower = input.toLowerCase().trim();
-    // Very short inputs (1-4 chars) that look like greetings
-    if (lower.length <= 4) {
-        const shortGreetings = ['hi', 'hii', 'hey', 'yo', 'sup', 'ok', 'yes', 'no', 'yep', 'nah', 'bye', 'thx', 'ty'];
-        if (shortGreetings.some(g => lower.startsWith(g))) {
-            return true;
-        }
-    }
-    const casualPatterns = [
-        /^h+i+!*$/i, // hi, hii, hiii, etc
-        /^he+y+!*$/i, // hey, heyy, heyyy
-        /^y+o+!*$/i, // yo, yoo, yooo
-        /^(hello|hola|howdy|greetings)[\s!.,]*$/i,
-        /^(good\s*(morning|afternoon|evening|night))[\s!.,]*$/i,
-        /^(what'?s?\s*up|how\s*are\s*you|how'?s?\s*it\s*going)[\s!?.,]*$/i,
-        /^(thanks|thank\s*you|thx|ty)[\s!.,]*$/i,
-        /^(bye|goodbye|see\s*ya|later|cya)[\s!.,]*$/i,
-        /^(ok|okay|sure|yes|no|yep|nope|yeah|nah)[\s!.,]*$/i,
-        /^(cool|nice|great|awesome|perfect|lol|lmao)[\s!.,]*$/i,
-        /^(sup|wassup|wazzup)[\s!.,]*$/i,
-    ];
-    return casualPatterns.some(pattern => pattern.test(lower));
-}
-// Check if input is a short simple question
-function isSimpleQuestion(input) {
-    const lower = input.toLowerCase().trim();
-    // Short questions that don't need code context
-    if (input.length < 50 && /\?$/.test(input)) {
-        return true;
+// ============================================================================
+// EXECUTION HANDLERS
+// ============================================================================
+async function getApiKey() {
+    try {
+        return await (0, auth_1.ensureAuthenticated)();
     }
-    // Direct questions
-    if (/^(what|why|how|when|where|who|can you|could you|would you|will you)\s/i.test(lower)) {
-        return true;
+    catch {
+        console.log((0, ui_1.error)('Authentication required. Run: zcode auth'));
+        return null;
     }
-    return false;
 }
-// Intent classification (rule-based, no model)
-function classifyIntent(input) {
-    const lower = input.toLowerCase().trim();
-    // CASUAL CHAT - handle separately
-    if (isCasualChat(input)) {
-        return 'QUESTION'; // Route to chat handler
-    }
-    // QUESTION - explicit questions
-    if (/^(what|why|how|when|where|who|explain|clarify|describe|tell me)/i.test(lower) ||
-        /\?$/.test(lower) ||
-        /^(is|are|can|could|would|should|do|does|did|has|have|will)\s/i.test(lower)) {
-        return 'QUESTION';
-    }
-    // DEBUG
-    if (/(fix|debug|error|bug|issue|broken|failing|crash|exception|problem|wrong|doesn'?t work|not working)/i.test(lower)) {
-        return 'DEBUG';
-    }
-    // REFACTOR
-    if (/(refactor|rename|reorganize|restructure|extract|move|split|merge|consolidate|clean up|cleanup|simplify)/i.test(lower)) {
-        return 'REFACTOR';
-    }
-    // REVIEW
-    if (/(review|analyze|audit|check|inspect|examine|assess|evaluate|look at|understand|read|show me)/i.test(lower)) {
-        return 'REVIEW';
-    }
-    // CODE_EDIT - file operations
-    if (/(add|create|implement|update|change|modify|write|build|make|generate|new|feature|function|component|edit|insert|append|remove|delete|replace|file|folder|directory)/i.test(lower)) {
-        return 'CODE_EDIT';
+// Handle casual chat
+async function handleChat(input) {
+    const apiKey = await getApiKey();
+    if (!apiKey)
+        return;
+    const chatPrompt = `You are a friendly AI coding assistant. Respond naturally and briefly (1-2 sentences). Be warm and helpful. If the user wants to code, suggest they describe their task.`;
+    const result = await (0, runtime_1.execute)({
+        instruction: `${chatPrompt}\n\nUser: ${input}\n\nRespond briefly:`,
+        enforceSchema: false
+    }, apiKey);
+    if (result.success && result.output) {
+        console.log(extractTextFromResponse(result.output));
     }
-    // Default to QUESTION for short inputs, CODE_EDIT for longer ones
-    if (input.length < 30) {
-        return 'QUESTION';
+    else {
+        console.log("Hey! What would you like to build today?");
     }
-    return 'CODE_EDIT';
 }
-// Determine workflow based on mode and intent
-function determineWorkflow(intent, input) {
-    const mode = (0, session_1.getMode)();
-    // Casual chat always goes to chat handler
-    if (isCasualChat(input)) {
-        return 'chat';
-    }
-    // Simple questions go to ask handler
-    if (isSimpleQuestion(input) && intent === 'QUESTION') {
-        return 'ask_question';
-    }
-    // Read-only modes route to ask_question workflow
-    if (mode === 'ask' || mode === 'explain' || mode === 'review') {
-        return 'ask_question';
-    }
-    // Auto mode - execute directly without manual steps
-    if (mode === 'auto') {
-        return 'auto_execute';
+// Handle questions
+async function handleQuestion(input) {
+    const apiKey = await getApiKey();
+    if (!apiKey)
+        return;
+    const session = (0, session_1.getSession)();
+    console.log((0, ui_1.dim)('Thinking...'));
+    const result = await (0, runtime_1.execute)({
+        instruction: `You are a helpful coding assistant. Answer this question clearly and concisely:\n\n${input}`,
+        enforceSchema: false
+    }, apiKey);
+    if (result.success && result.output) {
+        console.log(extractTextFromResponse(result.output));
     }
-    // Questions in edit mode still get answered
-    if (intent === 'QUESTION') {
-        return 'ask_question';
+    else {
+        console.log((0, ui_1.error)(result.error || 'Failed to get answer'));
     }
-    return 'capture_intent';
 }
-// Handle question/explain/review in read-only modes
-async function handleAskQuestion(input) {
-    try {
-        let apiKey;
-        try {
-            apiKey = await (0, auth_1.ensureAuthenticated)();
-        }
-        catch (authError) {
-            console.log((0, ui_1.error)(`Authentication required: ${authError?.message || 'Run zcode auth'}`));
-            return { handled: true };
-        }
-        if (!apiKey) {
-            console.log((0, ui_1.error)('No API key configured. Run "zcode auth" to set up.'));
-            return { handled: true };
-        }
-        const session = (0, session_1.getSession)();
-        const mode = (0, session_1.getMode)();
-        const modePrompt = (0, mode_prompts_1.buildSystemPrompt)(mode, session.workingDirectory);
-        const instruction = `${modePrompt}
+// Handle simple edits - direct execution
+async function handleSimpleEdit(input) {
+    const apiKey = await getApiKey();
+    if (!apiKey)
+        return;
+    const session = (0, session_1.getSession)();
+    console.log((0, ui_1.info)('⚡ Executing...'));
+    const { buildContext, formatContextForModel } = await Promise.resolve().then(() => __importStar(require('./context/context_builder')));
+    const context = buildContext(session.workingDirectory, input, 'CODE_EDIT', session.openFiles);
+    const filesContext = formatContextForModel(context);
+    const instruction = `You are an autonomous coding agent. Execute this task completely.
 
-User input: ${input}
+Task: ${input}
+Working directory: ${session.workingDirectory}
+${filesContext ? `\nRelevant files:\n${filesContext}` : ''}
 
-Respond directly and concisely.`;
-        console.log((0, ui_1.dim)('Thinking...'));
-        const result = await (0, runtime_1.execute)({ instruction, enforceSchema: false }, apiKey);
-        if (result.success && result.output) {
-            const text = extractTextFromResponse(result.output);
-            console.log(text);
+RESPOND WITH JSON ONLY:
+{
+  "status": "success",
+  "files": [{"path": "path/to/file", "operation": "create|modify|delete", "content": "full content"}],
+  "output": "Brief explanation"
+}
+
+RULES:
+- Create folders by creating files inside them (folders auto-create)
+- Provide COMPLETE file content, never partial
+- Only modify files directly related to the task`;
+    const result = await (0, runtime_1.execute)({ instruction }, apiKey);
+    if (result.success && result.output) {
+        const response = parseFileOperations(result.output) ||
+            (typeof result.output === 'object' ? result.output : null);
+        if (response?.files?.length) {
+            await applyFiles(response.files, session.workingDirectory, input);
+            if (response.output)
+                console.log('\n' + response.output);
+        }
+        else if (response?.output) {
+            console.log(response.output);
         }
         else {
-            console.log((0, ui_1.error)(`Failed: ${result.error || 'Unknown error'}`));
+            const text = extractTextFromResponse(result.output);
+            if (text && !text.startsWith('{'))
+                console.log(text);
         }
-        return { handled: true };
     }
-    catch (e) {
-        console.log((0, ui_1.error)(`Error: ${e?.message || e}`));
-        return { handled: true };
+    else {
+        console.log((0, ui_1.error)(result.error || 'Execution failed'));
     }
 }
-// Handle auto execution - plan, generate, and apply in one go
-async function handleAutoExecute(input) {
-    // SAFETY: Check if this looks like a real coding task
-    // If input is too short or vague, don't execute file operations
-    const looksLikeTask = input.length > 10 &&
-        /(create|add|implement|build|make|write|update|modify|fix|change|delete|remove|refactor)/i.test(input);
-    if (!looksLikeTask) {
-        // Treat as a question instead
-        console.log((0, ui_1.dim)('Input too vague for auto mode. Treating as question...'));
-        return handleAskQuestion(input);
-    }
-    try {
-        let apiKey;
-        try {
-            apiKey = await (0, auth_1.ensureAuthenticated)();
-        }
-        catch (authError) {
-            console.log((0, ui_1.error)(`Authentication required: ${authError?.message || 'Run zcode auth'}`));
-            return { handled: true };
-        }
-        if (!apiKey) {
-            console.log((0, ui_1.error)('No API key configured. Run "zcode auth" to set up.'));
-            return { handled: true };
-        }
-        const session = (0, session_1.getSession)();
-        const modePrompt = (0, mode_prompts_1.buildSystemPrompt)('auto', session.workingDirectory);
-        console.log((0, ui_1.info)('Executing autonomously...'));
-        // Build context from workspace for better results
-        const { buildContext, formatContextForModel } = await Promise.resolve().then(() => __importStar(require('./context/context_builder')));
-        const context = buildContext(session.workingDirectory, input, 'CODE_EDIT', session.openFiles.map(f => require('path').join(session.workingDirectory, f)));
-        const filesContext = formatContextForModel(context);
-        const instruction = `${modePrompt}
+// Handle complex tasks - plan then execute
+async function handleComplexTask(input) {
+    const apiKey = await getApiKey();
+    if (!apiKey)
+        return;
+    const session = (0, session_1.getSession)();
+    (0, session_1.setIntent)(input);
+    console.log((0, ui_1.info)('📋 Complex task detected - creating plan...'));
+    const { buildContext, formatContextForModel } = await Promise.resolve().then(() => __importStar(require('./context/context_builder')));
+    const context = buildContext(session.workingDirectory, input, 'CODE_EDIT', session.openFiles);
+    const filesContext = formatContextForModel(context);
+    // Step 1: Generate plan
+    const planInstruction = `Create a step-by-step plan for this task.
 
 Task: ${input}
-
 Working directory: ${session.workingDirectory}
+${filesContext ? `\nFiles:\n${filesContext}` : ''}
+
+Respond with JSON:
+{
+  "status": "success",
+  "plan": [
+    {"id": "1", "description": "Step description", "files": ["affected/files"]}
+  ],
+  "output": "Plan summary"
+}`;
+    console.log((0, ui_1.dim)('Planning...'));
+    const planResult = await (0, runtime_1.execute)({ instruction: planInstruction }, apiKey);
+    if (!planResult.success) {
+        console.log((0, ui_1.error)('Planning failed: ' + planResult.error));
+        return;
+    }
+    const planResponse = parseFileOperations(planResult.output);
+    const plan = planResponse?.plan;
+    if (!plan || !Array.isArray(plan) || plan.length === 0) {
+        console.log((0, ui_1.dim)('No plan generated, executing directly...'));
+        return handleSimpleEdit(input);
+    }
+    // Show plan
+    console.log((0, ui_1.success)(`Plan: ${plan.length} steps`));
+    plan.forEach((step, i) => {
+        console.log(`  ${i + 1}. ${step.description}`);
+    });
+    (0, session_1.setLastPlan)(plan.map((s) => ({ id: s.id, description: s.description, status: 'pending' })));
+    // Step 2: Execute plan
+    console.log('');
+    console.log((0, ui_1.dim)('Executing plan...'));
+    const executeInstruction = `Execute this plan and generate all file changes.
+
+Task: ${input}
 
-${filesContext ? `Relevant files:\n${filesContext}` : ''}
+Plan:
+${plan.map((s, i) => `${i + 1}. ${s.description}`).join('\n')}
 
-CRITICAL INSTRUCTIONS:
-1. You MUST respond with valid JSON containing file operations
-2. To create a folder, create a file inside it (folders are created automatically)
-3. NEVER just describe what you would do - actually provide the file operations
-4. For "create folder X", respond with a file like "X/.gitkeep" or "X/README.md"
+Working directory: ${session.workingDirectory}
+${filesContext ? `\nFiles:\n${filesContext}` : ''}
 
-REQUIRED JSON FORMAT:
+Respond with JSON containing ALL file operations:
 {
   "status": "success",
-  "files": [
-    {"path": "folder/file.ext", "operation": "create", "content": "file content"}
-  ],
-  "output": "Brief explanation"
+  "files": [{"path": "path/to/file", "operation": "create|modify|delete", "content": "COMPLETE content"}],
+  "output": "Summary of changes"
 }
 
-RULES:
-- Only create/modify files DIRECTLY related to the task
-- NEVER create files in src/ unless explicitly asked
-- Use .zai/ folder for internal/temporary files
-- Folders are created automatically when you create files inside them
-
-Respond with JSON only. No markdown, no explanation outside the JSON.`;
-        const result = await (0, runtime_1.execute)({ instruction }, apiKey);
-        if (result.success && result.output) {
-            // Try to parse as ResponseSchema first
-            let response = parseFileOperations(result.output);
-            // If direct parsing failed, try the output object
-            if (!response && typeof result.output === 'object') {
-                response = result.output;
-            }
-            // If no files array, just show the output
-            if (!response || !response.files || response.files.length === 0) {
-                if (response && response.output) {
-                    console.log(response.output);
-                }
-                else {
-                    const text = extractTextFromResponse(result.output);
-                    if (text && !text.startsWith('{')) {
-                        console.log(text);
-                    }
-                }
-                return { handled: true };
-            }
-            // Check if there are file operations
-            if (response && response.files && response.files.length > 0) {
-                // SAFETY: Filter out suspicious file operations
-                const safeFiles = response.files.filter(file => {
-                    const filePath = file.path.toLowerCase();
-                    // Block creating files in src/ unless task explicitly mentions it
-                    if (filePath.startsWith('src/') && !input.toLowerCase().includes('src')) {
-                        console.log((0, ui_1.dim)(`  Skipped ${file.path} (not in task scope)`));
-                        return false;
-                    }
-                    // Block creating files outside project
-                    if (filePath.startsWith('/') || filePath.startsWith('..')) {
-                        console.log((0, ui_1.dim)(`  Skipped ${file.path} (outside project)`));
-                        return false;
-                    }
-                    return true;
-                });
-                if (safeFiles.length > 0) {
-                    console.log((0, ui_1.success)(`Applying ${safeFiles.length} file(s)...`));
-                    let applied = 0;
-                    let failed = 0;
-                    for (const file of safeFiles) {
-                        try {
-                            // Normalize the path
-                            let filePath = file.path;
-                            if (filePath.startsWith('./')) {
-                                filePath = filePath.substring(2);
-                            }
-                            const opResult = (0, apply_1.applyFileOperation)(file.operation, filePath, file.content, {
-                                basePath: session.workingDirectory
-                            });
-                            if (opResult.success) {
-                                console.log((0, ui_1.success)(`  ${file.operation}: ${filePath}`));
-                                applied++;
-                            }
-                            else {
-                                console.log((0, ui_1.error)(`  Failed ${filePath}: ${opResult.error}`));
-                                failed++;
-                            }
-                        }
-                        catch (e) {
-                            console.log((0, ui_1.error)(`  Failed ${file.path}: ${e?.message}`));
-                            failed++;
-                        }
-                    }
-                    console.log('');
-                    if (applied > 0) {
-                        console.log((0, ui_1.success)(`Applied ${applied} file(s)`));
-                    }
-                    if (failed > 0) {
-                        console.log((0, ui_1.error)(`Failed ${failed} file(s)`));
-                    }
-                    console.log((0, ui_1.hint)('/undo to rollback'));
-                }
-            }
-            // Show output/explanation
-            if (response && response.output) {
-                console.log('');
-                console.log(response.output);
-            }
-            else if (response && response.error) {
-                console.log((0, ui_1.error)(response.error));
-            }
-            else if (!response) {
-                // No structured response - try to show something useful
-                const text = extractTextFromResponse(result.output);
-                // Don't dump raw JSON to the user
-                if (text && !text.startsWith('{') && !text.startsWith('[')) {
-                    console.log(text);
-                }
-                else if (text) {
-                    // It's JSON that we couldn't parse - show a friendly message
-                    console.log((0, ui_1.dim)('Response received but could not be processed.'));
-                    console.log((0, ui_1.dim)('Try rephrasing your request or use /do for step-by-step mode.'));
-                }
-            }
-        }
-        else {
-            console.log((0, ui_1.error)(`Failed: ${result.error || 'Unknown error'}`));
-        }
-        return { handled: true };
+IMPORTANT: Include COMPLETE file content for every file. Never use placeholders.`;
+    const execResult = await (0, runtime_1.execute)({ instruction: executeInstruction }, apiKey);
+    if (!execResult.success) {
+        console.log((0, ui_1.error)('Execution failed: ' + execResult.error));
+        return;
     }
-    catch (e) {
-        console.log((0, ui_1.error)(`Error: ${e?.message || e}`));
-        return { handled: true };
+    const execResponse = parseFileOperations(execResult.output) ||
+        (typeof execResult.output === 'object' ? execResult.output : null);
+    if (execResponse?.files?.length) {
+        await applyFiles(execResponse.files, session.workingDirectory, input);
+        if (execResponse.output)
+            console.log('\n' + execResponse.output);
     }
-}
-// Handle workflow
-async function handleWorkflow(workflow, input, parsed, intent) {
-    switch (workflow) {
-        case 'slash_command':
-            await (0, commands_1.executeCommand)(parsed);
-            return { handled: true };
-        case 'chat':
-            return handleChat(input);
-        case 'ask_question':
-            return handleAskQuestion(input);
-        case 'auto_execute':
-            return handleAutoExecute(input);
-        case 'capture_intent':
-            (0, session_1.setIntent)(input);
-            (0, session_1.setIntentType)(intent);
-            // Provide clear feedback about what was captured
-            const intentLabel = intent.toLowerCase().replace('_', ' ');
-            console.log(`Task captured: "${input.substring(0, 60)}${input.length > 60 ? '...' : ''}"`);
-            console.log(`Type: ${intentLabel}`);
-            console.log('');
-            console.log((0, ui_1.hint)('Type /plan to create execution plan'));
-            return { handled: true };
-        case 'append_context':
-            const existing = (0, session_1.getIntent)();
-            if (existing) {
-                (0, session_1.setIntent)(`${existing}\n\nClarification: ${input}`);
-                console.log((0, ui_1.dim)('Context updated.'));
-                console.log((0, ui_1.hint)('/plan'));
-                return { handled: true };
-            }
-            (0, session_1.setIntent)(input);
-            console.log((0, ui_1.dim)('Intent captured.'));
-            console.log((0, ui_1.hint)('/plan'));
-            return { handled: true };
-        case 'confirm_action':
-            const session = (0, session_1.getSession)();
-            if (session.pendingActions) {
-                console.log((0, ui_1.hint)('/diff or /apply'));
-                return { handled: true };
-            }
-            console.log((0, ui_1.dim)('Nothing pending.'));
-            return { handled: true };
-        case 'ignore':
-            return { handled: true };
-        default:
-            return { handled: false };
+    else if (execResponse?.output) {
+        console.log(execResponse.output);
+    }
+    else {
+        console.log((0, ui_1.dim)('No file changes generated.'));
     }
 }
-// Handle casual chat - greetings, small talk
-async function handleChat(input) {
-    try {
-        let apiKey;
-        try {
-            apiKey = await (0, auth_1.ensureAuthenticated)();
-        }
-        catch (authError) {
-            console.log((0, ui_1.error)(`Authentication required: ${authError?.message || 'Run zcode auth'}`));
-            return { handled: true };
+// Apply files helper
+async function applyFiles(files, basePath, input) {
+    if (!files || files.length === 0)
+        return;
+    // Safety filter
+    const safeFiles = files.filter(file => {
+        const p = file.path.toLowerCase();
+        if (p.startsWith('src/') && !input.toLowerCase().includes('src')) {
+            console.log((0, ui_1.dim)(`  Skipped ${file.path} (not in task scope)`));
+            return false;
         }
-        if (!apiKey) {
-            console.log((0, ui_1.error)('No API key configured. Run "zcode auth" to set up.'));
-            return { handled: true };
+        if (p.startsWith('/') || p.startsWith('..')) {
+            console.log((0, ui_1.dim)(`  Skipped ${file.path} (outside project)`));
+            return false;
         }
-        // Simple chat prompt - no code context needed
-        const chatPrompt = `You are a friendly AI coding assistant. Respond naturally and briefly to casual conversation.
-Keep responses short (1-2 sentences). Be warm and helpful.
-If the user seems to want to start coding, suggest they describe their task.`;
-        const instruction = `${chatPrompt}
-
-User: ${input}
-
-Respond briefly and naturally:`;
-        console.log((0, ui_1.dim)('...'));
-        const result = await (0, runtime_1.execute)({ instruction, enforceSchema: false }, apiKey);
-        if (result.success && result.output) {
-            const text = extractTextFromResponse(result.output);
-            console.log(text);
+        return true;
+    });
+    if (safeFiles.length === 0)
+        return;
+    console.log((0, ui_1.success)(`Applying ${safeFiles.length} file(s)...`));
+    let applied = 0, failed = 0;
+    for (const file of safeFiles) {
+        try {
+            let filePath = file.path.startsWith('./') ? file.path.substring(2) : file.path;
+            const result = (0, apply_1.applyFileOperation)(file.operation, filePath, file.content, { basePath });
+            if (result.success) {
+                console.log((0, ui_1.success)(`  ✓ ${file.operation}: ${filePath}`));
+                applied++;
+            }
+            else {
+                console.log((0, ui_1.error)(`  ✗ ${filePath}: ${result.error}`));
+                failed++;
+            }
         }
-        else {
-            // Fallback for chat errors - just be friendly
-            const greetings = {
-                'hi': 'Hey! What would you like to build today?',
-                'hello': 'Hello! Ready to code something awesome?',
-                'hey': 'Hey there! What can I help you with?',
-                'yo': 'Yo! What are we building?',
-                'sup': 'Not much! What are you working on?',
-                'thanks': 'You\'re welcome! Need anything else?',
-                'thank you': 'Happy to help! What\'s next?',
-                'bye': 'See you! Happy coding!',
-                'ok': 'Great! Let me know if you need anything.',
-                'cool': 'Awesome! What\'s next?',
-            };
-            const lower = input.toLowerCase().trim().replace(/[!.,?]/g, '');
-            const response = greetings[lower] || 'Hey! Describe what you\'d like to build.';
-            console.log(response);
+        catch (e) {
+            console.log((0, ui_1.error)(`  ✗ ${file.path}: ${e?.message}`));
+            failed++;
         }
-        return { handled: true };
-    }
-    catch (e) {
-        // Fallback on any error
-        console.log('Hey! What would you like to build today?');
-        return { handled: true };
     }
+    console.log('');
+    if (applied > 0)
+        console.log((0, ui_1.success)(`Applied ${applied} file(s)`));
+    if (failed > 0)
+        console.log((0, ui_1.error)(`Failed ${failed} file(s)`));
+    console.log((0, ui_1.hint)('/undo to rollback'));
 }
-// Main orchestration entry
 async function orchestrate(input) {
     const trimmed = input.trim();
     if (!trimmed) {
-        return {
-            inputType: 'free_text',
-            intent: 'COMMAND',
-            workflow: 'ignore',
-            handled: true,
-        };
+        return { inputType: 'free_text', intent: 'COMMAND', workflow: 'ignore', handled: true };
     }
+    // Handle slash commands
     const parsed = (0, commands_1.parseInput)(trimmed);
-    // Slash commands
     if (parsed.isSlashCommand) {
         await (0, commands_1.executeCommand)(parsed);
-        return {
-            inputType: 'slash',
-            intent: 'COMMAND',
-            workflow: 'slash_command',
-            handled: true,
-        };
+        return { inputType: 'slash', intent: 'COMMAND', workflow: 'slash_command', handled: true };
+    }
+    // Analyze the task
+    const analysis = analyzeTask(trimmed);
+    // Route based on analysis
+    switch (analysis.type) {
+        case 'chat':
+            await handleChat(trimmed);
+            return { inputType: 'free_text', intent: 'QUESTION', workflow: 'chat', handled: true };
+        case 'question':
+            await handleQuestion(trimmed);
+            return { inputType: 'free_text', intent: 'QUESTION', workflow: 'question', handled: true };
+        case 'debug':
+        case 'refactor':
+        case 'simple_edit':
+            if (analysis.needsPlan) {
+                await handleComplexTask(trimmed);
+            }
+            else {
+                await handleSimpleEdit(trimmed);
+            }
+            return { inputType: 'free_text', intent: 'CODE_EDIT', workflow: 'auto_execute', handled: true };
+        case 'complex_task':
+            await handleComplexTask(trimmed);
+            return { inputType: 'free_text', intent: 'CODE_EDIT', workflow: 'planned_execute', handled: true };
+        default:
+            await handleSimpleEdit(trimmed);
+            return { inputType: 'free_text', intent: 'CODE_EDIT', workflow: 'auto_execute', handled: true };
     }
-    // Free text - classify and route
-    const intent = classifyIntent(trimmed);
-    const workflow = determineWorkflow(intent, trimmed);
-    const result = await handleWorkflow(workflow, trimmed, parsed, intent);
-    return {
-        inputType: 'free_text',
-        intent,
-        workflow,
-        handled: result.handled,
-        message: result.message,
-    };
 }
 //# sourceMappingURL=orchestrator.js.map