codeep 1.0.6 → 1.0.8

package/dist/utils/agent.d.ts

@@ -5,6 +5,7 @@ import { ProjectContext } from './project';
 import { ToolCall, ToolResult, ActionLog } from './tools';
 import { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession, ActionSession } from './history';
 import { VerifyResult } from './verify';
+import { TaskPlan, SubTask } from './taskPlanner';
 export interface AgentOptions {
     maxIterations: number;
     maxDuration: number;
@@ -13,10 +14,13 @@ export interface AgentOptions {
     onIteration?: (iteration: number, message: string) => void;
     onThinking?: (text: string) => void;
     onVerification?: (results: VerifyResult[]) => void;
+    onTaskPlan?: (plan: TaskPlan) => void;
+    onTaskUpdate?: (task: SubTask) => void;
     abortSignal?: AbortSignal;
     dryRun?: boolean;
     autoVerify?: boolean;
     maxFixAttempts?: number;
+    usePlanning?: boolean;
 }
 export interface AgentResult {
     success: boolean;

package/dist/utils/agent.js

@@ -7,9 +7,11 @@ import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools } from '
 import { startSession, endSession, undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession } from './history.js';
 import { runAllVerifications, formatErrorsForAgent, hasVerificationErrors, getVerificationSummary } from './verify.js';
 import { gatherSmartContext, formatSmartContext, extractTargetFile } from './smartContext.js';
+import { planTasks, formatTaskPlan } from './taskPlanner.js';
 const DEFAULT_OPTIONS = {
     maxIterations: 100, // Increased for large tasks
     maxDuration: 20 * 60 * 1000, // 20 minutes
+    usePlanning: true, // Enable task planning by default
 };
 /**
  * Generate system prompt for agent mode (used with native tool calling)
@@ -25,13 +27,15 @@ function getAgentSystemPrompt(projectContext) {
 - List directory contents
 
 ## IMPORTANT: Follow User Instructions Exactly
-- Do EXACTLY what the user asks, nothing more
+- Do EXACTLY what the user asks - complete the ENTIRE task
+- If user says "create a website" -> create ALL necessary files (HTML, CSS, JS, etc.)
 - If user says "create folder X" -> use create_directory tool to create folder X
 - If user says "delete file X" -> use delete_file tool to delete file X
-- Do NOT interpret or expand simple requests into complex tasks
-- Simple tasks should be completed in 1-2 tool calls
+- Do NOT stop after just 1-2 tool calls unless the task is trivially simple
+- Complex tasks (like creating websites) require MANY tool calls to complete
 - The user may write in any language - understand their request and execute it
 - Tool names and parameters must ALWAYS be in English (e.g., "create_directory", not "kreiraj_direktorij")
+- KEEP WORKING until the entire task is finished - do not stop prematurely
 
 ## Rules
 1. Always read files before editing them to understand the current content
@@ -68,12 +72,15 @@ function getFallbackSystemPrompt(projectContext) {
     return `You are an AI coding agent with FULL autonomous access to this project.
 
 ## IMPORTANT: Follow User Instructions Exactly
-- Do EXACTLY what the user asks, nothing more
+- Do EXACTLY what the user asks - complete the ENTIRE task
+- If user says "create a website" -> create ALL necessary files (HTML, CSS, JS, etc.)
 - If user says "create folder X" -> use create_directory tool
-- If user says "delete file X" -> use delete_file tool  
-- Do NOT interpret or expand simple requests into complex tasks
+- If user says "delete file X" -> use delete_file tool
+- Do NOT stop after just 1-2 tool calls unless the task is trivially simple
+- Complex tasks (like creating websites) require MANY tool calls to complete
 - The user may write in any language - understand and execute
 - Tool names and parameters must ALWAYS be in English
+- KEEP WORKING until the entire task is finished - do not stop prematurely
 
 ## Available Tools
 ${formatToolDefinitions()}
@@ -372,6 +379,28 @@ export async function runAgent(prompt, projectContext, options = {}) {
     const messages = [];
     // Start history session for undo support
     const sessionId = startSession(prompt, projectContext.root || process.cwd());
+    // Task planning phase (if enabled and prompt is complex enough)
+    let taskPlan = null;
+    if (opts.usePlanning && prompt.split(' ').length > 5) {
+        try {
+            opts.onIteration?.(0, 'Planning tasks...');
+            taskPlan = await planTasks(prompt, {
+                name: projectContext.name,
+                type: projectContext.type,
+                structure: projectContext.structure,
+            });
+            if (taskPlan.tasks.length > 1) {
+                opts.onTaskPlan?.(taskPlan);
+            }
+            else {
+                taskPlan = null; // Single task, no need for planning
+            }
+        }
+        catch (error) {
+            // Planning failed, continue without it
+            taskPlan = null;
+        }
+    }
     // Gather smart context based on the task
     const targetFile = extractTargetFile(prompt);
     const smartContext = gatherSmartContext(targetFile, projectContext, prompt);
@@ -387,8 +416,12 @@ export async function runAgent(prompt, projectContext, options = {}) {
     if (smartContextStr) {
         systemPrompt += '\n\n' + smartContextStr;
     }
-    // Initial user message
-    messages.push({ role: 'user', content: prompt });
+    // Initial user message with optional task plan
+    let initialPrompt = prompt;
+    if (taskPlan) {
+        initialPrompt = `${prompt}\n\n## Task Breakdown\nI've broken this down into subtasks. Complete them in order:\n\n${formatTaskPlan(taskPlan)}\n\nStart with task 1.`;
+    }
+    messages.push({ role: 'user', content: initialPrompt });
     let iteration = 0;
     let finalResponse = '';
     let result;
@@ -446,18 +479,41 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     toolCalls = textToolCalls;
                 }
             }
-            // If no tool calls, this is the final response
+            // If no tool calls, check if this is really the final response
+            // Don't exit on first iteration without tool calls - agent might be thinking
             if (toolCalls.length === 0) {
-                // Remove <think>...</think> tags from response (some models include thinking)
-                finalResponse = content.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
-                break;
-            }
-            // Also check if response indicates completion (even with tool calls)
-            const completionIndicators = ['task completed', 'finished', 'done with', 'successfully created', 'all set'];
-            const lowerContent = content.toLowerCase();
-            if (completionIndicators.some(indicator => lowerContent.includes(indicator))) {
-                // Agent thinks task is complete, but included tool calls - execute them and finish
-                // Continue with tool execution but mark this as potentially the last iteration
+                // Only accept as final response if:
+                // 1. We've done at least some work (iteration > 2)
+                // 2. Agent explicitly indicates completion
+                const completionIndicators = [
+                    'task is complete',
+                    'all files have been created',
+                    'website has been created',
+                    'successfully completed',
+                    'everything is ready',
+                    'all done'
+                ];
+                const lowerContent = content.toLowerCase();
+                const indicatesCompletion = completionIndicators.some(indicator => lowerContent.includes(indicator));
+                if (iteration > 2 && indicatesCompletion) {
+                    // Remove <think>...</think> tags from response
+                    finalResponse = content.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+                    break;
+                }
+                else if (iteration <= 2) {
+                    // Too early to quit - remind agent to continue
+                    messages.push({ role: 'assistant', content });
+                    messages.push({
+                        role: 'user',
+                        content: 'Continue with the task. Use the tools to complete what was requested. Do not stop until all files are created and the task is fully complete.'
+                    });
+                    continue;
+                }
+                else {
+                    // Later iteration without completion indicator - accept as final
+                    finalResponse = content.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+                    break;
+                }
             }
             // Add assistant response to history
             messages.push({ role: 'assistant', content });
@@ -492,9 +548,12 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 }
             }
             // Add tool results to messages
+            const nextStepPrompt = iteration < 5
+                ? `Tool results:\n\n${toolResults.join('\n\n')}\n\nGood progress! Continue working on the task. Use more tools to complete what was requested. Only stop when EVERYTHING is finished and working.`
+                : `Tool results:\n\n${toolResults.join('\n\n')}\n\nContinue with the task. If the task is fully complete, provide a final summary without any tool calls.`;
             messages.push({
                 role: 'user',
-                content: `Tool results:\n\n${toolResults.join('\n\n')}\n\nContinue with the task. If done, provide a final summary without any tool calls.`,
+                content: nextStepPrompt,
             });
         }
         // Check if we hit max iterations

package/dist/utils/taskPlanner.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Task Planning - breaks down complex tasks into subtasks
+ */
+export interface SubTask {
+    id: number;
+    description: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+    dependencies?: number[];
+}
+export interface TaskPlan {
+    originalPrompt: string;
+    tasks: SubTask[];
+    estimatedIterations: number;
+}
+/**
+ * Ask AI to break down a complex task into subtasks
+ */
+export declare function planTasks(userPrompt: string, projectContext: {
+    name: string;
+    type: string;
+    structure: string;
+}): Promise<TaskPlan>;
+/**
+ * Check if a task's dependencies are completed
+ */
+export declare function canStartTask(task: SubTask, allTasks: SubTask[]): boolean;
+/**
+ * Get next task to execute
+ */
+export declare function getNextTask(tasks: SubTask[]): SubTask | null;
+/**
+ * Format task plan for display
+ */
+export declare function formatTaskPlan(plan: TaskPlan): string;

package/dist/utils/taskPlanner.js

@@ -0,0 +1,160 @@
+/**
+ * Task Planning - breaks down complex tasks into subtasks
+ */
+import { config, getApiKey } from '../config/index.js';
+import { getProviderBaseUrl, getProviderAuthHeader } from '../config/providers.js';
+/**
+ * Ask AI to break down a complex task into subtasks
+ */
+export async function planTasks(userPrompt, projectContext) {
+    const systemPrompt = `You are a task planning expert. Break down user requests into clear, sequential subtasks.
+
+RULES:
+1. Create 3-15 subtasks maximum
+2. Each subtask should be specific and actionable
+3. Order tasks logically (dependencies first)
+4. Use simple, clear descriptions
+5. Respond ONLY with a JSON object, no other text
+
+Example response format:
+{
+  "tasks": [
+    {"id": 1, "description": "Create project directory structure", "dependencies": []},
+    {"id": 2, "description": "Create index.html with basic structure", "dependencies": [1]},
+    {"id": 3, "description": "Create styles.css with base styles", "dependencies": [1]},
+    {"id": 4, "description": "Add navigation to all pages", "dependencies": [2, 3]}
+  ]
+}
+
+Project Context:
+- Name: ${projectContext.name}
+- Type: ${projectContext.type}
+
+User Request: ${userPrompt}
+
+Break this down into subtasks. Respond with JSON only.`;
+    try {
+        const apiKey = await getApiKey();
+        if (!apiKey) {
+            throw new Error('No API key configured');
+        }
+        const protocol = config.get('protocol');
+        const provider = config.get('provider');
+        const model = config.get('model');
+        const baseUrl = getProviderBaseUrl(provider, protocol);
+        const authHeaderType = getProviderAuthHeader(provider, protocol);
+        const messages = [
+            { role: 'user', content: systemPrompt }
+        ];
+        const requestBody = protocol === 'anthropic'
+            ? {
+                model,
+                max_tokens: 2048,
+                messages,
+                system: 'You are a task planning assistant. Respond with JSON only.',
+            }
+            : {
+                model,
+                messages: [
+                    { role: 'system', content: 'You are a task planning assistant. Respond with JSON only.' },
+                    ...messages
+                ],
+                temperature: 0.3,
+                max_tokens: 2048,
+            };
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (authHeaderType === 'x-api-key') {
+            headers['x-api-key'] = apiKey;
+        }
+        else {
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        }
+        const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            throw new Error(`API request failed: ${response.statusText}`);
+        }
+        const data = await response.json();
+        const content = protocol === 'anthropic'
+            ? data.content?.[0]?.text || ''
+            : data.choices?.[0]?.message?.content || '';
+        // Extract JSON from response (handle markdown code blocks)
+        let jsonStr = content.trim();
+        if (jsonStr.startsWith('```json')) {
+            jsonStr = jsonStr.replace(/```json\n?/g, '').replace(/```\n?/g, '');
+        }
+        else if (jsonStr.startsWith('```')) {
+            jsonStr = jsonStr.replace(/```\n?/g, '');
+        }
+        const parsed = JSON.parse(jsonStr);
+        // Validate and convert to TaskPlan
+        const tasks = parsed.tasks.map((t, index) => ({
+            id: t.id || index + 1,
+            description: t.description,
+            status: 'pending',
+            dependencies: t.dependencies || [],
+        }));
+        return {
+            originalPrompt: userPrompt,
+            tasks,
+            estimatedIterations: tasks.length * 3, // Rough estimate
+        };
+    }
+    catch (error) {
+        // Fallback: create a single task
+        return {
+            originalPrompt: userPrompt,
+            tasks: [
+                {
+                    id: 1,
+                    description: userPrompt,
+                    status: 'pending',
+                    dependencies: [],
+                }
+            ],
+            estimatedIterations: 10,
+        };
+    }
+}
+/**
+ * Check if a task's dependencies are completed
+ */
+export function canStartTask(task, allTasks) {
+    if (!task.dependencies || task.dependencies.length === 0) {
+        return true;
+    }
+    return task.dependencies.every(depId => {
+        const depTask = allTasks.find(t => t.id === depId);
+        return depTask?.status === 'completed';
+    });
+}
+/**
+ * Get next task to execute
+ */
+export function getNextTask(tasks) {
+    return tasks.find(t => t.status === 'pending' && canStartTask(t, tasks)) || null;
+}
+/**
+ * Format task plan for display
+ */
+export function formatTaskPlan(plan) {
+    const lines = ['Task Plan:', ''];
+    plan.tasks.forEach(task => {
+        const icon = task.status === 'completed' ? '✓'
+            : task.status === 'in_progress' ? '⏳'
+                : task.status === 'failed' ? '✗'
+                    : '⏸';
+        const deps = task.dependencies && task.dependencies.length > 0
+            ? ` (after: ${task.dependencies.join(', ')})`
+            : '';
+        lines.push(`${icon} ${task.id}. ${task.description}${deps}`);
+    });
+    lines.push('');
+    lines.push(`Estimated iterations: ~${plan.estimatedIterations}`);
+    return lines.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",