codeep 1.2.69 → 1.2.71

package/README.md

@@ -357,13 +357,17 @@ Main modules: src, components, hooks, utils
 - Naming: camelCase
 ```
 
-### Self-Verification
-After making changes, the agent automatically:
-1. Runs **build** to check for compilation errors
-2. Runs **tests** to ensure nothing is broken
-3. Runs **type checking** for TypeScript/PHP projects
-4. If errors found → automatically tries to fix them (up to 3 attempts)
-5. Reports final verification status
+### Self-Verification (Optional)
+When enabled in Settings, the agent can automatically verify its changes by running build, tests, or type checking after completing a task. Disabled by default — the agent works freely and you decide when to verify.
+
+Configure in **Settings → Agent Auto-Verify**:
+- **Off** (default) — no automatic verification
+- **Build only** — checks compilation after changes
+- **Typecheck only** — runs TypeScript/PHP type checking
+- **Test only** — runs test suite after changes
+- **Build + Typecheck + Test** — full verification
+
+If errors are found, the agent tries to fix them automatically (up to 3 attempts, configurable).
 
 **Supported project types:**
 
@@ -681,8 +685,8 @@ With write access enabled:
 | Agent Confirmation | Dangerous | `Never`, `Dangerous` (default), or `Always` |
 | Agent Auto-Commit | Off | Automatically commit after agent completes |
 | Agent Branch | Off | Create new branch for agent commits |
-| Agent Auto-Verify | On | Automatically run build/test after changes |
-| Agent Max Fix Attempts | 3 | Max attempts to auto-fix errors |
+| Agent Auto-Verify | Off | `Off`, `Build only`, `Typecheck only`, `Test only`, or `Build + Typecheck + Test` |
+| Agent Max Fix Attempts | 3 | Max attempts to auto-fix errors (when Auto-Verify is enabled) |
 
 ## Usage Examples
 

package/dist/api/index.js

@@ -293,7 +293,7 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
     const timeoutId = setTimeout(() => { timedOut = true; controller.abort(); }, timeout);
     // Listen to external abort signal if provided (user cancel)
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => controller.abort());
+        abortSignal.addEventListener('abort', () => controller.abort(), { once: true });
     }
     // Build headers based on auth type
     const headers = {
@@ -413,7 +413,7 @@ async function chatAnthropic(message, history, model, apiKey, onChunk, abortSign
     const timeoutId = setTimeout(() => { timedOut = true; controller.abort(); }, timeout);
     // Listen to external abort signal if provided (user cancel)
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => controller.abort());
+        abortSignal.addEventListener('abort', () => controller.abort(), { once: true });
     }
     // Build headers based on auth type
     const headers = {

package/dist/config/index.d.ts

@@ -33,7 +33,7 @@ interface ConfigSchema {
     agentConfirmation: 'always' | 'dangerous' | 'never';
     agentAutoCommit: boolean;
     agentAutoCommitBranch: boolean;
-    agentAutoVerify: boolean;
+    agentAutoVerify: 'off' | 'build' | 'typecheck' | 'test' | 'all';
     agentMaxFixAttempts: number;
     agentMaxIterations: number;
     agentMaxDuration: number;

package/dist/config/index.js

@@ -146,7 +146,7 @@ function createConfig() {
         agentConfirmation: 'dangerous',
         agentAutoCommit: false,
         agentAutoCommitBranch: false,
-        agentAutoVerify: true,
+        agentAutoVerify: 'off',
         agentMaxFixAttempts: 3,
         agentMaxIterations: 100,
         agentMaxDuration: 20,

package/dist/renderer/agentExecution.js

@@ -9,6 +9,16 @@ import { chat } from '../api/index.js';
 import { runAgent } from '../utils/agent.js';
 import { config, autoSaveSession } from '../config/index.js';
 import { getGitStatus } from '../utils/git.js';
+function getActionType(toolName) {
+    return toolName.includes('write') ? 'write' :
+        toolName.includes('edit') ? 'edit' :
+            toolName.includes('read') ? 'read' :
+                toolName.includes('delete') ? 'delete' :
+                    toolName.includes('list') ? 'list' :
+                        toolName.includes('search') || toolName.includes('grep') ? 'search' :
+                            toolName.includes('mkdir') ? 'mkdir' :
+                                toolName.includes('fetch') ? 'fetch' : 'command';
+}
 // ─── Dangerous tool detection ────────────────────────────────────────────────
 const DANGEROUS_TOOLS = ['write', 'edit', 'delete', 'command', 'execute', 'shell', 'rm', 'mv'];
 export function isDangerousTool(toolName, parameters) {
@@ -154,14 +164,7 @@ export async function executeAgentTask(task, dryRun, ctx) {
                 const target = tool.parameters.path ||
                     tool.parameters.command ||
                     tool.parameters.pattern || '';
-                const actionType = toolName.includes('write') ? 'write' :
-                    toolName.includes('edit') ? 'edit' :
-                        toolName.includes('read') ? 'read' :
-                            toolName.includes('delete') ? 'delete' :
-                                toolName.includes('list') ? 'list' :
-                                    toolName.includes('search') || toolName.includes('grep') ? 'search' :
-                                        toolName.includes('mkdir') ? 'mkdir' :
-                                            toolName.includes('fetch') ? 'fetch' : 'command';
+                const actionType = getActionType(toolName);
                 const shortTarget = target.length > 50 ? '...' + target.slice(-47) : target;
                 app.setAgentThinking(`${actionType}: ${shortTarget}`);
                 if (actionType === 'write' && tool.parameters.content) {
@@ -247,14 +250,7 @@ export async function executeAgentTask(task, dryRun, ctx) {
             onToolResult: (result, toolCall) => {
                 const toolName = toolCall.tool.toLowerCase();
                 const target = toolCall.parameters.path || toolCall.parameters.command || '';
-                const actionType = toolName.includes('write') ? 'write' :
-                    toolName.includes('edit') ? 'edit' :
-                        toolName.includes('read') ? 'read' :
-                            toolName.includes('delete') ? 'delete' :
-                                toolName.includes('list') ? 'list' :
-                                    toolName.includes('search') || toolName.includes('grep') ? 'search' :
-                                        toolName.includes('mkdir') ? 'mkdir' :
-                                            toolName.includes('fetch') ? 'fetch' : 'command';
+                const actionType = getActionType(toolName);
                 app.updateAgentProgress(0, {
                     type: actionType,
                     target,
@@ -324,11 +320,13 @@ export async function executeAgentTask(task, dryRun, ctx) {
             app.addMessage({ role: 'assistant', content: 'Agent stopped by user.' });
         }
         else {
-            const failLines = [];
-            if (result.finalResponse)
-                failLines.push(result.finalResponse);
-            failLines.push(`**Agent stopped**: ${result.error || 'Unknown error'}`);
-            app.addMessage({ role: 'assistant', content: failLines.join('\n\n') });
+            // Show the agent's summary if available, with error details below
+            if (result.finalResponse) {
+                app.addMessage({ role: 'assistant', content: result.finalResponse });
+            }
+            else {
+                app.addMessage({ role: 'assistant', content: `Agent could not complete the task: ${result.error || 'Unknown error'}` });
+            }
         }
         autoSaveSession(app.getMessages(), ctx.projectPath);
     }

package/dist/renderer/components/Settings.js

@@ -115,11 +115,14 @@ export const SETTINGS = [
     {
         key: 'agentAutoVerify',
         label: 'Agent Auto-Verify',
-        getValue: () => config.get('agentAutoVerify') !== false,
+        getValue: () => config.get('agentAutoVerify'),
         type: 'select',
         options: [
-            { value: true, label: 'On' },
-            { value: false, label: 'Off' },
+            { value: 'off', label: 'Off' },
+            { value: 'build', label: 'Build only' },
+            { value: 'typecheck', label: 'Typecheck only' },
+            { value: 'test', label: 'Test only' },
+            { value: 'all', label: 'Build + Typecheck + Test' },
         ],
     },
     {

package/dist/utils/agent.d.ts

@@ -25,7 +25,7 @@ export interface AgentOptions {
     onTaskUpdate?: (task: SubTask) => void;
     abortSignal?: AbortSignal;
     dryRun?: boolean;
-    autoVerify?: boolean;
+    autoVerify?: 'off' | 'build' | 'typecheck' | 'test' | 'all' | boolean;
     maxFixAttempts?: number;
     usePlanning?: boolean;
     chatHistory?: Array<{

package/dist/utils/agent.js

@@ -16,7 +16,7 @@ export { loadProjectRules, formatChatHistoryForAgent };
  * Calculate dynamic timeout based on task complexity
  * Complex tasks (creating pages, multiple files) need more time
  */
-function calculateDynamicTimeout(prompt, iteration, baseTimeout) {
+function calculateDynamicTimeout(iteration, baseTimeout) {
     // Simple approach: just use base timeout with small multiplier for later iterations
     // Complex calculations were causing more problems than they solved
     let multiplier = 1.0;
@@ -224,11 +224,11 @@ export async function runAgent(prompt, projectContext, options = {}) {
             if (compressed !== messages) {
                 messages.length = 0;
                 messages.push(...compressed);
-                opts.onIteration?.(iteration, `Context compressed (${compressed.length} messages kept)`);
+                opts.onIteration?.(iteration, `Context compressed to save memory — continuing with last ${compressed.length} messages`);
             }
             debug(`Starting iteration ${iteration}/${opts.maxIterations}, actions: ${actions.length}`);
             // Calculate dynamic timeout based on task complexity
-            const dynamicTimeout = calculateDynamicTimeout(prompt, iteration, baseTimeout);
+            const dynamicTimeout = calculateDynamicTimeout(iteration, baseTimeout);
             debug(`Using timeout: ${dynamicTimeout}ms (base: ${baseTimeout}ms)`);
             // Get AI response with retry logic for timeouts
             let chatResponse = null;
@@ -283,23 +283,37 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
                         continue;
                     }
-                    // Retry on transient errors: rate-limit, server errors, network failures
+                    // All non-abort errors are retryable — retry with backoff
+                    retryCount++;
                     const isRateLimit = err.message.includes('429');
                     const isServerError = err.message.includes('500') || err.message.includes('502') || err.message.includes('503') || err.message.includes('529');
-                    const isNetworkError = ['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'ENOTFOUND', 'EPIPE', 'EAI_AGAIN'].some(code => err.message.includes(code));
-                    if (isRateLimit || isServerError || isNetworkError) {
-                        retryCount++;
-                        const waitSec = Math.min(5 * retryCount, 30); // 5s, 10s, 15s … max 30s
-                        const code = isRateLimit ? '429' : isServerError ? '5xx' : 'network';
-                        debug(`${code} error (retry ${retryCount}/${maxTimeoutRetries}), waiting ${waitSec}s`);
-                        opts.onIteration?.(iteration, `Server error (${code}), retrying in ${waitSec}s... (${retryCount}/${maxTimeoutRetries})`);
-                        if (retryCount >= maxTimeoutRetries) {
-                            throw error; // Give up after max retries
+                    const code = isRateLimit ? '429' : isServerError ? '5xx' : 'error';
+                    const waitSec = Math.min(5 * retryCount, 30);
+                    debug(`${code} (retry ${retryCount}/${maxTimeoutRetries}): ${err.message}`);
+                    opts.onIteration?.(iteration, `API ${code}, retrying in ${waitSec}s... (${retryCount}/${maxTimeoutRetries})`);
+                    if (retryCount >= maxTimeoutRetries) {
+                        // Don't throw — skip this iteration like timeouts do
+                        consecutiveTimeouts++;
+                        if (consecutiveTimeouts >= maxConsecutiveTimeouts) {
+                            result = {
+                                success: false,
+                                iterations: iteration,
+                                actions,
+                                finalResponse: actions.length > 0
+                                    ? `Agent made progress (${actions.length} actions) but API errors prevented completion. You can continue by running the agent again.`
+                                    : 'Agent could not complete the task due to repeated API errors. Check your API key and network connection.',
+                                error: `API failed after ${maxTimeoutRetries} retries: ${err.message}`,
+                            };
+                            return result;
                         }
-                        await new Promise(resolve => setTimeout(resolve, waitSec * 1000));
-                        continue;
+                        messages.push({
+                            role: 'user',
+                            content: 'The previous request failed. Please continue with the task.'
+                        });
+                        break; // Break retry loop, continue main loop
                     }
-                    throw error;
+                    await new Promise(resolve => setTimeout(resolve, waitSec * 1000));
+                    continue;
                 }
             }
             // If we broke out due to max retries without a response, continue to next iteration
@@ -326,7 +340,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     .replace(/<arg_key>[\s\S]*?<\/arg_value>/gi, '')
                     .replace(/Tool parameters:[\s\S]*?(?=\n\n|$)/gi, '')
                     .replace(/\{'path'[\s\S]*?\}/g, '')
-                    .replace(/```[\s\S]*?```/g, '')
+                    .replace(/```(?:json|tool_call)?\s*\{[\s\S]*?\}\s*```/g, '') // Only strip tool-call-like code blocks
                     .trim();
                 // Check if model indicates it wants to continue (incomplete response)
                 const continueIndicators = [
@@ -426,11 +440,14 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 else {
                     toolResults.push(`Tool ${toolCall.tool} failed:\n${toolResult.error || 'Unknown error'}`);
                 }
-                // Invalidate read cache when a file is written/edited
+                // Invalidate read cache when files may have changed
                 if ((toolCall.tool === 'write_file' || toolCall.tool === 'edit_file') && toolResult.success) {
                     const filePath = toolCall.parameters.path || '';
                     readCache.delete(filePath);
                 }
+                else if (toolCall.tool === 'execute_command' && toolResult.success) {
+                    readCache.clear(); // Commands can modify arbitrary files
+                }
             }
             // Add tool results to messages
             messages.push({
@@ -457,9 +474,11 @@ export async function runAgent(prompt, projectContext, options = {}) {
             return result;
         }
         // Self-verification: Run build/test and fix errors if needed
-        const autoVerify = opts.autoVerify ?? config.get('agentAutoVerify');
+        const autoVerifyRaw = opts.autoVerify ?? config.get('agentAutoVerify');
+        // Support legacy boolean values: true -> 'all', false -> 'off'
+        const autoVerify = autoVerifyRaw === true ? 'all' : autoVerifyRaw === false ? 'off' : autoVerifyRaw;
         const maxFixAttempts = opts.maxFixAttempts ?? config.get('agentMaxFixAttempts');
-        if (autoVerify && !opts.dryRun) {
+        if (autoVerify !== 'off' && !opts.dryRun) {
             // Check if we made any file changes worth verifying
             const hasFileChanges = actions.some(a => a.type === 'write' || a.type === 'edit' || a.type === 'delete');
             if (hasFileChanges) {
@@ -471,15 +490,30 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         break;
                     }
                     opts.onIteration?.(iteration, `Verification attempt ${fixAttempt + 1}/${maxFixAttempts}`);
-                    // Run verifications
+                    // Run verifications based on selected mode
                     const verifyResults = await runAllVerifications(projectContext.root || process.cwd(), {
-                        runBuild: true,
-                        runTest: true,
-                        runTypecheck: true,
+                        runBuild: autoVerify === 'all' || autoVerify === 'build',
+                        runTest: autoVerify === 'all' || autoVerify === 'test',
+                        runTypecheck: autoVerify === 'all' || autoVerify === 'typecheck',
                         runLint: false,
                     });
                     opts.onVerification?.(verifyResults);
-                    // Check if all passed
+                    // Filter errors: only keep those related to files the agent touched
+                    const touchedFiles = new Set(actions
+                        .filter(a => a.type === 'write' || a.type === 'edit')
+                        .map(a => a.target));
+                    for (const vr of verifyResults) {
+                        vr.errors = vr.errors.filter(e => {
+                            if (!e.file)
+                                return true; // Keep errors without file info (build failures etc)
+                            return touchedFiles.has(e.file) || [...touchedFiles].some(f => e.file.endsWith(f) || f.endsWith(e.file));
+                        });
+                        // Update success based on remaining errors
+                        if (vr.errors.filter(e => e.severity === 'error').length === 0) {
+                            vr.success = true;
+                        }
+                    }
+                    // Check if all passed (after filtering)
                     if (!hasVerificationErrors(verifyResults)) {
                         const summary = getVerificationSummary(verifyResults);
                         finalResponse += `\n\n✓ Verification passed: ${summary.passed}/${summary.total} checks`;
@@ -543,7 +577,8 @@ export async function runAgent(prompt, projectContext, options = {}) {
                             const actionLog = createActionLog(toolCall, toolResult);
                             actions.push(actionLog);
                             if (toolResult.success) {
-                                fixResults.push(`Tool ${toolCall.tool} succeeded:\n${toolResult.output}`);
+                                const truncated = truncateToolResult(toolResult.output, toolCall.tool);
+                                fixResults.push(`Tool ${toolCall.tool} succeeded:\n${truncated}`);
                             }
                             else {
                                 fixResults.push(`Tool ${toolCall.tool} failed:\n${toolResult.error || 'Unknown error'}`);

package/dist/utils/agentChat.js

@@ -154,7 +154,7 @@ export async function agentChat(messages, systemPrompt, onChunk, abortSignal, dy
     let isTimeout = false;
     const timeout = setTimeout(() => { isTimeout = true; controller.abort(); }, timeoutMs);
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => { isTimeout = false; controller.abort(); });
+        abortSignal.addEventListener('abort', () => { isTimeout = false; controller.abort(); }, { once: true });
     }
     const headers = { 'Content-Type': 'application/json' };
     if (authHeader === 'Bearer') {
@@ -268,7 +268,7 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
     let isTimeout = false;
     const timeout = setTimeout(() => { isTimeout = true; controller.abort(); }, timeoutMs);
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => { isTimeout = false; controller.abort(); });
+        abortSignal.addEventListener('abort', () => { isTimeout = false; controller.abort(); }, { once: true });
     }
     const headers = { 'Content-Type': 'application/json' };
     if (authHeader === 'Bearer') {

package/dist/utils/shell.js

@@ -112,8 +112,8 @@ export function validateCommand(command, args, options) {
     }
     // Special validation for rm command
     if (command === 'rm') {
-        const hasRecursive = args.some(a => a.includes('r'));
-        const hasForce = args.some(a => a.includes('f'));
+        const hasRecursive = args.some(a => a.startsWith('-') && a.includes('r'));
+        const hasForce = args.some(a => a.startsWith('-') && a.includes('f'));
         if (hasRecursive && hasForce) {
             // rm -rf requires extra validation
             const paths = args.filter(a => !a.startsWith('-'));

package/dist/utils/toolExecution.js

@@ -176,8 +176,8 @@ export async function executeTool(toolCall, projectRoot) {
                     return { success: false, output: '', error: 'Missing required parameter: path', tool, parameters };
                 }
                 if (content === undefined || content === null) {
-                    debug('write_file: content was undefined, using placeholder');
-                    content = '<!-- Content was not provided -->\n';
+                    debug('write_file failed: content was undefined');
+                    return { success: false, output: '', error: 'File content was empty or truncated by the API. Try writing a smaller file or splitting into multiple writes.', tool, parameters };
                 }
                 const validation = validatePath(path, projectRoot);
                 if (!validation.valid)

package/dist/utils/verify.js

@@ -134,14 +134,15 @@ async function runVerifyCommand(type, command, args, projectRoot, timeout) {
     const output = result.stdout + '\n' + result.stderr;
     // Parse errors from output
     const errors = parseErrors(output, type);
-    // If command failed but no errors were parsed, surface the failure reason explicitly
+    // If command failed but no errors were parsed, surface the failure reason as warning
+    // (not error — could be pre-existing build issue unrelated to agent's changes)
     if (!result.success && errors.length === 0) {
         const reason = result.stderr?.includes('timed out')
-            ? `Command timed out after ${Math.round(duration / 1000)}s. This build tool may be too slow for verification. Consider adding a faster typecheck script to package.json.`
+            ? `Command timed out after ${Math.round(duration / 1000)}s. This build tool may be too slow for verification.`
             : result.stderr?.includes('not in the allowed list') || result.stderr?.includes('not allowed')
                 ? `Command '${command}' is not allowed. Check shell.ts ALLOWED_COMMANDS.`
                 : result.stderr?.trim() || result.stdout?.trim() || 'Command failed with no output';
-        errors.push({ severity: 'error', message: reason });
+        errors.push({ severity: 'warning', message: reason });
     }
     return {
         success: result.success,
@@ -390,25 +391,26 @@ export async function runLintVerification(projectRoot, timeout = 60000) {
 export async function runAllVerifications(projectRoot, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
     const results = [];
-    // Run typecheck first (fastest feedback)
-    if (opts.runTypecheck) {
-        const result = await runTypecheckVerification(projectRoot, opts.timeout);
-        if (result)
-            results.push(result);
+    // Run typecheck and lint in parallel (independent checks)
+    const parallel = [];
+    if (opts.runTypecheck)
+        parallel.push(runTypecheckVerification(projectRoot, opts.timeout));
+    if (opts.runLint)
+        parallel.push(runLintVerification(projectRoot, opts.timeout));
+    if (parallel.length > 0) {
+        const parallelResults = await Promise.all(parallel);
+        for (const r of parallelResults) {
+            if (r)
+                results.push(r);
+        }
     }
-    // Run build
+    // Run build after typecheck/lint (may depend on them)
     if (opts.runBuild) {
         const result = await runBuildVerification(projectRoot, opts.timeout);
         if (result)
             results.push(result);
     }
-    // Run lint
-    if (opts.runLint) {
-        const result = await runLintVerification(projectRoot, opts.timeout);
-        if (result)
-            results.push(result);
-    }
-    // Run tests last (slowest)
+    // Run tests last (slowest, depends on build)
     if (opts.runTest) {
         const result = await runTestVerification(projectRoot, opts.timeout);
         if (result)

package/package.json

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