codeep 1.0.5 → 1.0.7

package/dist/config/index.d.ts

@@ -35,6 +35,8 @@ interface ConfigSchema {
     agentAutoCommitBranch: boolean;
     agentAutoVerify: boolean;
     agentMaxFixAttempts: number;
+    agentMaxIterations: number;
+    agentMaxDuration: number;
     projectPermissions: ProjectPermission[];
     providerApiKeys: ProviderApiKey[];
 }

package/dist/config/index.js

@@ -66,6 +66,8 @@ export const config = new Conf({
         agentAutoCommitBranch: false,
         agentAutoVerify: true, // Auto-verify by default
         agentMaxFixAttempts: 3,
+        agentMaxIterations: 100,
+        agentMaxDuration: 20, // minutes
         protocol: 'openai',
         plan: 'lite',
         language: 'en',

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: 50, // Increased for complex tasks like website creation
-    maxDuration: 10 * 60 * 1000, // 10 minutes
+    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)
@@ -358,12 +360,42 @@ async function handleStream(body, protocol, onChunk) {
  * Run the agent loop
  */
 export async function runAgent(prompt, projectContext, options = {}) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
+    // Load limits from config
+    const configMaxIterations = config.get('agentMaxIterations');
+    const configMaxDuration = config.get('agentMaxDuration') * 60 * 1000; // convert minutes to ms
+    const opts = {
+        ...DEFAULT_OPTIONS,
+        maxIterations: configMaxIterations,
+        maxDuration: configMaxDuration,
+        ...options
+    };
     const startTime = Date.now();
     const actions = [];
     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);
@@ -379,8 +411,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;

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.5",
+  "version": "1.0.7",
   "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",