codeep 1.0.25 → 1.0.28

package/dist/app.js

@@ -291,7 +291,15 @@ export const App = () => {
                     });
                 },
                 onThinking: (text) => {
-                    setAgentThinking(prev => prev + text);
+                    // Strip <think> and <tool_call> tags from thinking text
+                    const cleanText = text
+                        .replace(/<think>[\s\S]*?<\/think>/gi, '')
+                        .replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '')
+                        .replace(/<toolcall>[\s\S]*?<\/toolcall>/gi, '')
+                        .trim();
+                    if (cleanText) {
+                        setAgentThinking(prev => prev + cleanText);
+                    }
                 },
                 abortSignal: controller.signal,
             });

package/dist/components/Message.js

@@ -19,7 +19,15 @@ export function getCodeBlock(index) {
 }
 export const MessageView = memo(({ role, content }) => {
     if (role === 'user') {
-        return (_jsx(Box, { marginY: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", bold: true, children: '> ' }), _jsx(Text, { children: content })] }) }));
+        // For long user messages, truncate display but keep full content for processing
+        const maxDisplayLength = 500;
+        const isLong = content.length > maxDisplayLength;
+        const displayContent = isLong
+            ? content.substring(0, maxDisplayLength) + '...'
+            : content;
+        // Replace multiple newlines with single space for cleaner display
+        const cleanContent = displayContent.replace(/\n+/g, ' ').replace(/\s+/g, ' ').trim();
+        return (_jsxs(Box, { marginY: 1, flexDirection: "column", children: [_jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: "#f02a30", bold: true, children: '> ' }), _jsx(Text, { children: cleanContent })] }), isLong && (_jsxs(Text, { color: "gray", dimColor: true, children: ["  (", content.length, " characters total)"] }))] }));
     }
     if (role === 'system') {
         return (_jsx(Box, { marginY: 1, justifyContent: "center", children: _jsx(Text, { italic: true, children: content }) }));

package/dist/config/index.js

@@ -68,7 +68,7 @@ export const config = new Conf({
         agentMaxFixAttempts: 3,
         agentMaxIterations: 100,
         agentMaxDuration: 20, // minutes
-        agentApiTimeout: 120000, // 120 seconds base timeout for agent (dynamically adjusted)
+        agentApiTimeout: 180000, // 180 seconds base timeout for agent (dynamically adjusted)
         protocol: 'openai',
         plan: 'lite',
         language: 'en',

package/dist/utils/agent.js

@@ -75,6 +75,7 @@ function getAgentSystemPrompt(projectContext) {
 8. Use execute_command ONLY for: npm, git, composer, pip, cargo (build/package managers)
 9. When the task is complete, respond with a summary WITHOUT any tool calls
 10. IMPORTANT: After finishing, your response must NOT include any tool calls - just provide a summary
+11. IGNORE the .codeep folder - it contains internal configuration, do NOT read or modify it
 
 ## Self-Verification
 After you make changes, the system will automatically run build and tests.
@@ -142,6 +143,7 @@ When you need to use a tool, respond with:
 5. Use execute_command ONLY for: npm, git, composer, pip, cargo (build/package managers)
 6. Always read files before editing
 7. When done, respond WITHOUT tool calls
+8. IGNORE the .codeep folder - it contains internal configuration, do NOT read or modify it
 
 ## Project: ${projectContext.name} (${projectContext.type})
 ${projectContext.structure}
@@ -205,7 +207,7 @@ async function agentChat(messages, systemPrompt, onChunk, abortSignal, dynamicTi
                 tools: getOpenAITools(),
                 tool_choice: 'auto',
                 temperature: config.get('temperature'),
-                max_tokens: config.get('maxTokens'),
+                max_tokens: Math.max(config.get('maxTokens'), 16384), // Ensure enough tokens for large file generation
             };
         }
         else {
@@ -216,7 +218,7 @@ async function agentChat(messages, systemPrompt, onChunk, abortSignal, dynamicTi
                 messages: messages,
                 tools: getAnthropicTools(),
                 temperature: config.get('temperature'),
-                max_tokens: config.get('maxTokens'),
+                max_tokens: Math.max(config.get('maxTokens'), 16384), // Ensure enough tokens for large file generation
             };
         }
         const response = await fetch(endpoint, {
@@ -234,24 +236,15 @@ async function agentChat(messages, systemPrompt, onChunk, abortSignal, dynamicTi
             throw new Error(`API error: ${response.status} - ${errorText}`);
         }
         const data = await response.json();
-        // Debug: log raw API response
-        console.error(`[DEBUG] Raw API response:`, JSON.stringify(data, null, 2).substring(0, 1000));
         if (protocol === 'openai') {
             const message = data.choices?.[0]?.message;
             const content = message?.content || '';
             const rawToolCalls = message?.tool_calls || [];
-            // Debug: log raw tool calls from API
-            console.error(`[DEBUG] Raw tool_calls from API:`, JSON.stringify(rawToolCalls, null, 2));
             const toolCalls = parseOpenAIToolCalls(rawToolCalls);
-            // Debug: log parsed tool calls
-            console.error(`[DEBUG] Parsed tool calls:`, JSON.stringify(toolCalls, null, 2));
             // If no native tool calls, try parsing from content (some models return text-based)
             if (toolCalls.length === 0 && content) {
-                console.error(`[DEBUG] No native tool calls, checking content for text-based calls...`);
-                console.error(`[DEBUG] Content preview:`, content.substring(0, 500));
                 const textToolCalls = parseToolCalls(content);
                 if (textToolCalls.length > 0) {
-                    console.error(`[DEBUG] Found ${textToolCalls.length} text-based tool calls`);
                     return { content, toolCalls: textToolCalls, usedNativeTools: false };
                 }
             }
@@ -524,6 +517,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
     let result;
     let consecutiveTimeouts = 0;
     const maxTimeoutRetries = 3;
+    const maxConsecutiveTimeouts = 9; // Allow more consecutive timeouts before giving up
     const baseTimeout = config.get('agentApiTimeout');
     try {
         while (iteration < opts.maxIterations) {
@@ -540,7 +534,6 @@ export async function runAgent(prompt, projectContext, options = {}) {
             }
             // Check abort signal
             if (opts.abortSignal?.aborted) {
-                console.error(`[DEBUG] Agent aborted at iteration ${iteration}, signal:`, opts.abortSignal.aborted);
                 result = {
                     success: false,
                     iterations: iteration,
@@ -551,11 +544,9 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 return result;
             }
             iteration++;
-            console.error(`[DEBUG] Starting iteration ${iteration}/${opts.maxIterations}, actions: ${actions.length}`);
             opts.onIteration?.(iteration, `Iteration ${iteration}/${opts.maxIterations}`);
             // Calculate dynamic timeout based on task complexity
             const dynamicTimeout = calculateDynamicTimeout(prompt, iteration, baseTimeout);
-            console.error(`[DEBUG] Using dynamic timeout: ${dynamicTimeout}ms (base: ${baseTimeout}ms, iteration: ${iteration})`);
             // Get AI response with retry logic for timeouts
             let chatResponse;
             let retryCount = 0;
@@ -563,7 +554,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 try {
                     chatResponse = await agentChat(messages, systemPrompt, opts.onThinking, opts.abortSignal, dynamicTimeout * (1 + retryCount * 0.5) // Increase timeout on retry
                     );
-                    consecutiveTimeouts = 0; // Reset on success
+                    consecutiveTimeouts = 0; // Reset consecutive count on success
                     break;
                 }
                 catch (error) {
@@ -583,23 +574,21 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     if (err.name === 'TimeoutError') {
                         retryCount++;
                         consecutiveTimeouts++;
-                        console.error(`[DEBUG] Timeout occurred (retry ${retryCount}/${maxTimeoutRetries}, consecutive: ${consecutiveTimeouts})`);
                         opts.onIteration?.(iteration, `API timeout, retrying (${retryCount}/${maxTimeoutRetries})...`);
                         if (retryCount >= maxTimeoutRetries) {
                             // Too many retries for this iteration
-                            if (consecutiveTimeouts >= maxTimeoutRetries * 2) {
+                            if (consecutiveTimeouts >= maxConsecutiveTimeouts) {
                                 // Too many consecutive timeouts overall, give up
                                 result = {
                                     success: false,
                                     iterations: iteration,
                                     actions,
                                     finalResponse: 'Agent stopped due to repeated API timeouts',
-                                    error: `API timed out ${consecutiveTimeouts} times consecutively. The task may be too complex or the API is overloaded.`,
+                                    error: `API timed out ${consecutiveTimeouts} times consecutively. Try increasing the timeout in settings or simplifying the task.`,
                                 };
                                 return result;
                             }
                             // Skip this iteration and try next
-                            console.error(`[DEBUG] Max retries reached, skipping to next iteration`);
                             messages.push({
                                 role: 'user',
                                 content: 'The previous request timed out. Please continue with the task, using simpler responses if needed.'
@@ -628,7 +617,6 @@ export async function runAgent(prompt, projectContext, options = {}) {
             }
             // If no tool calls, check if model wants to continue or is really done
             if (toolCalls.length === 0) {
-                console.error(`[DEBUG] No tool calls at iteration ${iteration}`);
                 // Remove <think>...</think> tags from response (some models include thinking)
                 finalResponse = content.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
                 // Check if model indicates it wants to continue (incomplete response)
@@ -643,7 +631,6 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 // by looking for incomplete actions (e.g., write_file without content)
                 const hasIncompleteWork = iteration < 10 && wantsToContinue && finalResponse.length < 500;
                 if (hasIncompleteWork) {
-                    console.error(`[DEBUG] Model wants to continue, prompting for next action`);
                     messages.push({ role: 'assistant', content });
                     messages.push({
                         role: 'user',
@@ -652,7 +639,6 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     continue;
                 }
                 // Model is done
-                console.error(`[DEBUG] Agent finished at iteration ${iteration}`);
                 break;
             }
             // Add assistant response to history

package/dist/utils/tools.js

@@ -210,25 +210,29 @@ export function parseOpenAIToolCalls(toolCalls) {
         if (!toolName)
             continue;
         let parameters = {};
+        const rawArgs = tc.function?.arguments || '{}';
         try {
-            parameters = JSON.parse(tc.function?.arguments || '{}');
+            parameters = JSON.parse(rawArgs);
         }
         catch (e) {
             // JSON parsing failed - likely truncated response
-            console.error(`[DEBUG] Failed to parse tool arguments for ${toolName}:`, tc.function?.arguments?.substring(0, 100));
-            continue; // Skip this tool call entirely
+            // Try to extract what we can from partial JSON
+            const partialParams = extractPartialToolParams(toolName, rawArgs);
+            if (partialParams) {
+                parameters = partialParams;
+            }
+            else {
+                continue;
+            }
         }
         // Validate required parameters for specific tools
         if (toolName === 'write_file' && (!parameters.path || parameters.content === undefined)) {
-            console.error(`[DEBUG] Skipping write_file with missing path or content`);
             continue;
         }
         if (toolName === 'read_file' && !parameters.path) {
-            console.error(`[DEBUG] Skipping read_file with missing path`);
             continue;
         }
         if (toolName === 'edit_file' && (!parameters.path || parameters.old_text === undefined || parameters.new_text === undefined)) {
-            console.error(`[DEBUG] Skipping edit_file with missing parameters`);
             continue;
         }
         parsed.push({
@@ -239,6 +243,87 @@ export function parseOpenAIToolCalls(toolCalls) {
     }
     return parsed;
 }
+/**
+ * Extract parameters from truncated/partial JSON for tool calls
+ * This is a fallback when JSON.parse fails due to API truncation
+ */
+function extractPartialToolParams(toolName, rawArgs) {
+    try {
+        // For write_file, try to extract path and content
+        if (toolName === 'write_file') {
+            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
+            const contentMatch = rawArgs.match(/"content"\s*:\s*"([\s\S]*?)(?:"|$)/);
+            if (pathMatch && contentMatch) {
+                // Unescape the content
+                let content = contentMatch[1];
+                content = content
+                    .replace(/\\n/g, '\n')
+                    .replace(/\\t/g, '\t')
+                    .replace(/\\r/g, '\r')
+                    .replace(/\\"/g, '"')
+                    .replace(/\\\\/g, '\\');
+                // If content appears truncated (doesn't end properly), add a comment
+                if (!content.endsWith('\n') && !content.endsWith('}') && !content.endsWith(';') && !content.endsWith('>')) {
+                    content += '\n<!-- Content may be truncated -->\n';
+                }
+                return { path: pathMatch[1], content };
+            }
+        }
+        // For read_file, just need path
+        if (toolName === 'read_file') {
+            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
+            if (pathMatch) {
+                return { path: pathMatch[1] };
+            }
+        }
+        // For list_files, just need path
+        if (toolName === 'list_files') {
+            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
+            if (pathMatch) {
+                return { path: pathMatch[1] };
+            }
+        }
+        // For create_directory, just need path
+        if (toolName === 'create_directory') {
+            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
+            if (pathMatch) {
+                return { path: pathMatch[1] };
+            }
+        }
+        // For edit_file, need path, old_text, new_text
+        if (toolName === 'edit_file') {
+            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
+            const oldTextMatch = rawArgs.match(/"old_text"\s*:\s*"([\s\S]*?)(?:"|$)/);
+            const newTextMatch = rawArgs.match(/"new_text"\s*:\s*"([\s\S]*?)(?:"|$)/);
+            if (pathMatch && oldTextMatch && newTextMatch) {
+                return {
+                    path: pathMatch[1],
+                    old_text: oldTextMatch[1].replace(/\\n/g, '\n').replace(/\\"/g, '"'),
+                    new_text: newTextMatch[1].replace(/\\n/g, '\n').replace(/\\"/g, '"'),
+                };
+            }
+        }
+        // For execute_command
+        if (toolName === 'execute_command') {
+            const commandMatch = rawArgs.match(/"command"\s*:\s*"([^"]+)"/);
+            if (commandMatch) {
+                const argsMatch = rawArgs.match(/"args"\s*:\s*\[([\s\S]*?)\]/);
+                let args = [];
+                if (argsMatch) {
+                    const argStrings = argsMatch[1].match(/"([^"]+)"/g);
+                    if (argStrings) {
+                        args = argStrings.map(s => s.replace(/"/g, ''));
+                    }
+                }
+                return { command: commandMatch[1], args };
+            }
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+}
 /**
  * Parse tool calls from Anthropic response
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.0.25",
+  "version": "1.0.28",
   "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",