codeep 1.0.29 → 1.0.33

package/README.md

@@ -497,11 +497,14 @@ With write access enabled:
 | Setting | Default | Description |
 |---------|---------|-------------|
 | Temperature | 0.7 | Response creativity (0.0 - 2.0) |
-| Max Tokens | 4096 | Maximum response length |
-| API Timeout | 30000ms | Request timeout |
+| Max Tokens | 8192 | Maximum response length |
+| API Timeout | 60000ms | Request timeout |
 | API Rate Limit | 30/min | Max API calls per minute |
 | Command Rate Limit | 100/min | Max commands per minute |
 | Agent Mode | Auto | `Auto` = agent runs on every message, `Manual` = use /agent |
+| Agent API Timeout | 180000ms | Timeout per agent API call (auto-adjusted for complexity) |
+| Agent Max Duration | 20 min | Maximum time for agent to run (5-60 min) |
+| Agent Max Iterations | 100 | Maximum agent iterations (10-200) |
 | 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 |

package/dist/app.js

@@ -266,8 +266,7 @@ export const App = () => {
         setAbortController(controller);
         try {
             const result = await runAgent(prompt, projectContext, {
-                maxIterations: 50, // Increased for complex tasks
-                maxDuration: 5 * 60 * 1000, // 5 minutes
+                // Use config values - no hardcoded limits
                 dryRun,
                 onIteration: (iteration, message) => {
                     setAgentIteration(iteration);

package/dist/components/Input.js

@@ -1,7 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useMemo, useEffect } from 'react';
+import { useState, useMemo, useEffect, useRef } from 'react';
 import { Text, Box, useInput } from 'ink';
-import TextInput from 'ink-text-input';
 import clipboard from 'clipboardy';
 const COMMANDS = [
     { cmd: '/help', desc: 'Show help' },
@@ -30,16 +29,20 @@ const COMMANDS = [
 ];
 export const ChatInput = ({ onSubmit, disabled, history = [], clearTrigger = 0 }) => {
     const [value, setValue] = useState('');
+    const [cursorPos, setCursorPos] = useState(0);
     const [selectedIndex, setSelectedIndex] = useState(0);
-    const [isSelectingCommand, setIsSelectingCommand] = useState(false);
     const [pasteInfo, setPasteInfo] = useState(null);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const lastInputTime = useRef(0);
+    const inputBuffer = useRef('');
     // Clear input when clearTrigger changes
     useEffect(() => {
         if (clearTrigger > 0) {
             setValue('');
+            setCursorPos(0);
             setSelectedIndex(0);
-            setIsSelectingCommand(false);
             setPasteInfo(null);
+            setHistoryIndex(-1);
         }
     }, [clearTrigger]);
     // Filter commands based on input
@@ -52,64 +55,227 @@ export const ChatInput = ({ onSubmit, disabled, history = [], clearTrigger = 0 }
     useEffect(() => {
         if (suggestions.length > 0) {
             setSelectedIndex(0);
-            setIsSelectingCommand(true);
+        }
+    }, [suggestions.length]);
+    // Detect paste by checking for rapid input (multiple chars in < 50ms)
+    const detectPaste = (newChars) => {
+        const now = Date.now();
+        const timeDiff = now - lastInputTime.current;
+        // If multiple characters arrive very quickly, it's likely a paste
+        if (timeDiff < 50 && newChars.length > 0) {
+            inputBuffer.current += newChars;
+            return true;
+        }
+        // Process any buffered paste
+        if (inputBuffer.current.length > 5) {
+            // This was a paste that just finished
+            const pastedText = inputBuffer.current;
+            inputBuffer.current = '';
+            handlePastedText(pastedText);
+            lastInputTime.current = now;
+            return true;
+        }
+        inputBuffer.current = newChars;
+        lastInputTime.current = now;
+        return false;
+    };
+    const handlePastedText = (text) => {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        const lines = trimmed.split(/\r?\n/);
+        const lineCount = lines.length;
+        const charCount = trimmed.length;
+        // For multi-line or long pastes, store info
+        if (lineCount > 1 || charCount > 100) {
+            const firstLine = lines[0].substring(0, 60);
+            const preview = firstLine + (lines[0].length > 60 ? '...' : '');
+            setPasteInfo({
+                lines: lineCount,
+                chars: charCount,
+                preview,
+                fullText: trimmed,
+            });
+            // Show indicator in input field
+            const indicator = `📋 [${lineCount} lines, ${charCount} chars]`;
+            setValue(prev => prev + indicator);
+            setCursorPos(prev => prev + indicator.length);
         }
         else {
-            setIsSelectingCommand(false);
+            // Short paste - insert directly
+            setValue(prev => prev + trimmed);
+            setCursorPos(prev => prev + trimmed.length);
+            setPasteInfo(null);
         }
-    }, [suggestions.length]);
-    // Handle keyboard navigation for command suggestions and paste
-    useInput(async (input, key) => {
+    };
+    // Main input handler
+    useInput((input, key) => {
         if (disabled)
             return;
-        // Handle paste (Ctrl+V) - read from clipboard and insert
+        // Handle Ctrl+V paste
         if (key.ctrl && input === 'v') {
-            try {
-                const clipboardText = await clipboard.read();
-                // Replace newlines with spaces to prevent multi-line issues
-                const sanitized = clipboardText.replace(/\r?\n/g, ' ').trim();
-                // Store full text
-                setValue(prev => prev + sanitized);
-                // Show paste info if long text
-                if (sanitized.length > 100) {
-                    setPasteInfo(`[pasted ${sanitized.length} chars]`);
-                    // Clear info after 2 seconds
-                    setTimeout(() => setPasteInfo(null), 2000);
+            clipboard.read().then(text => {
+                if (text) {
+                    handlePastedText(text);
+                }
+            }).catch(() => { });
+            return;
+        }
+        // Handle Enter - submit
+        if (key.return) {
+            if (value.trim()) {
+                let submitValue = value.trim();
+                // Replace paste indicator with actual content
+                if (pasteInfo && submitValue.includes('📋 [')) {
+                    submitValue = submitValue.replace(/📋 \[\d+ lines, \d+ chars\]/, pasteInfo.fullText);
                 }
+                onSubmit(submitValue);
+                setValue('');
+                setCursorPos(0);
+                setPasteInfo(null);
+                setHistoryIndex(-1);
             }
-            catch (error) {
-                // Clipboard read failed, ignore
+            return;
+        }
+        // Handle Escape - clear paste info or input
+        if (key.escape) {
+            if (pasteInfo) {
+                // Remove paste indicator from value
+                setValue(prev => prev.replace(/📋 \[\d+ lines, \d+ chars\]/, ''));
+                setPasteInfo(null);
+            }
+            else if (value) {
+                setValue('');
+                setCursorPos(0);
             }
             return;
         }
-        if (suggestions.length === 0)
+        // Handle Backspace
+        if (key.backspace || key.delete) {
+            if (cursorPos > 0) {
+                setValue(prev => prev.slice(0, cursorPos - 1) + prev.slice(cursorPos));
+                setCursorPos(prev => prev - 1);
+                // Clear paste info if we deleted the indicator
+                if (pasteInfo && !value.includes('📋 [')) {
+                    setPasteInfo(null);
+                }
+            }
             return;
-        // Navigate suggestions with up/down arrows
+        }
+        // Handle Tab - autocomplete command
+        if (key.tab && suggestions.length > 0) {
+            setValue(suggestions[selectedIndex].cmd + ' ');
+            setCursorPos(suggestions[selectedIndex].cmd.length + 1);
+            return;
+        }
+        // Handle Up Arrow - navigate suggestions or history
         if (key.upArrow) {
-            setSelectedIndex(i => Math.max(0, i - 1));
+            if (suggestions.length > 0) {
+                setSelectedIndex(i => Math.max(0, i - 1));
+            }
+            else if (history.length > 0) {
+                const newIndex = historyIndex < history.length - 1 ? historyIndex + 1 : historyIndex;
+                setHistoryIndex(newIndex);
+                if (newIndex >= 0 && history[history.length - 1 - newIndex]) {
+                    const historyValue = history[history.length - 1 - newIndex];
+                    setValue(historyValue);
+                    setCursorPos(historyValue.length);
+                }
+            }
             return;
         }
+        // Handle Down Arrow - navigate suggestions or history
         if (key.downArrow) {
-            setSelectedIndex(i => Math.min(suggestions.length - 1, i + 1));
+            if (suggestions.length > 0) {
+                setSelectedIndex(i => Math.min(suggestions.length - 1, i + 1));
+            }
+            else if (historyIndex > 0) {
+                const newIndex = historyIndex - 1;
+                setHistoryIndex(newIndex);
+                const historyValue = history[history.length - 1 - newIndex];
+                setValue(historyValue);
+                setCursorPos(historyValue.length);
+            }
+            else if (historyIndex === 0) {
+                setHistoryIndex(-1);
+                setValue('');
+                setCursorPos(0);
+            }
             return;
         }
-        // Tab to autocomplete selected command
-        if (key.tab) {
-            setValue(suggestions[selectedIndex].cmd);
-            setIsSelectingCommand(false);
+        // Handle Left Arrow
+        if (key.leftArrow) {
+            setCursorPos(prev => Math.max(0, prev - 1));
             return;
         }
-    }, { isActive: !disabled });
-    const handleChange = (newValue) => {
-        setValue(newValue);
-    };
-    const handleSubmit = () => {
-        if (value.trim() && !disabled) {
-            onSubmit(value.trim());
+        // Handle Right Arrow
+        if (key.rightArrow) {
+            setCursorPos(prev => Math.min(value.length, prev + 1));
+            return;
+        }
+        // Handle Ctrl+A - go to beginning
+        if (key.ctrl && input === 'a') {
+            setCursorPos(0);
+            return;
+        }
+        // Handle Ctrl+E - go to end
+        if (key.ctrl && input === 'e') {
+            setCursorPos(value.length);
+            return;
+        }
+        // Handle Ctrl+U - clear line
+        if (key.ctrl && input === 'u') {
             setValue('');
+            setCursorPos(0);
             setPasteInfo(null);
-            setIsSelectingCommand(false);
+            return;
+        }
+        // Handle Ctrl+W - delete word
+        if (key.ctrl && input === 'w') {
+            const beforeCursor = value.slice(0, cursorPos);
+            const afterCursor = value.slice(cursorPos);
+            const lastSpace = beforeCursor.trimEnd().lastIndexOf(' ');
+            const newBefore = lastSpace >= 0 ? beforeCursor.slice(0, lastSpace + 1) : '';
+            setValue(newBefore + afterCursor);
+            setCursorPos(newBefore.length);
+            return;
+        }
+        // Regular character input
+        if (input && !key.ctrl && !key.meta) {
+            // Check if this might be part of a paste
+            if (!detectPaste(input)) {
+                // Normal single character input
+                setValue(prev => prev.slice(0, cursorPos) + input + prev.slice(cursorPos));
+                setCursorPos(prev => prev + input.length);
+            }
+        }
+    }, { isActive: !disabled });
+    // Process any remaining buffered input after a delay
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            if (inputBuffer.current.length > 0) {
+                const buffered = inputBuffer.current;
+                inputBuffer.current = '';
+                if (buffered.length > 5) {
+                    handlePastedText(buffered);
+                }
+                else {
+                    setValue(prev => prev + buffered);
+                    setCursorPos(prev => prev + buffered.length);
+                }
+            }
+        }, 100);
+        return () => clearTimeout(timer);
+    }, [value]);
+    // Render input with cursor
+    const renderInput = () => {
+        if (!value) {
+            return _jsx(Text, { color: "gray", children: "Type a message or /command..." });
         }
+        const before = value.slice(0, cursorPos);
+        const cursor = value[cursorPos] || ' ';
+        const after = value.slice(cursorPos + 1);
+        return (_jsxs(Text, { children: [before, _jsx(Text, { backgroundColor: "white", color: "black", children: cursor }), after] }));
     };
-    return (_jsxs(Box, { flexDirection: "column", children: [suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [suggestions.map((s, i) => (_jsxs(Text, { children: [i === selectedIndex ? _jsx(Text, { color: "#f02a30", children: "\u25B8 " }) : '  ', _jsx(Text, { color: i === selectedIndex ? '#f02a30' : undefined, bold: i === selectedIndex, children: s.cmd }), _jsxs(Text, { color: i === selectedIndex ? undefined : 'gray', children: [" - ", s.desc] })] }, s.cmd))), _jsxs(Text, { color: "gray", children: ["\u2191\u2193 Navigate \u2022 Tab Complete \u2022 ", suggestions.length, " ", suggestions.length === 1 ? 'command' : 'commands'] })] })), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#f02a30", bold: true, children: '> ' }), disabled ? (_jsx(Text, { children: "..." })) : (_jsx(TextInput, { value: value, onChange: handleChange, onSubmit: handleSubmit, placeholder: "Type a message or /command..." }))] }), pasteInfo && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "green", children: pasteInfo }) }))] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [suggestions.slice(0, 8).map((s, i) => (_jsxs(Text, { children: [i === selectedIndex ? _jsx(Text, { color: "#f02a30", children: "\u25B8 " }) : '  ', _jsx(Text, { color: i === selectedIndex ? '#f02a30' : undefined, bold: i === selectedIndex, children: s.cmd }), _jsxs(Text, { color: i === selectedIndex ? undefined : 'gray', children: [" - ", s.desc] })] }, s.cmd))), _jsx(Text, { color: "gray", dimColor: true, children: "\u2191\u2193 navigate \u2022 Tab complete \u2022 Esc cancel" })] })), pasteInfo && (_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, marginBottom: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDCCB Pasted Content" }), _jsxs(Text, { children: [_jsx(Text, { color: "white", bold: true, children: pasteInfo.lines }), _jsxs(Text, { color: "gray", children: [" ", pasteInfo.lines === 1 ? 'line' : 'lines', " \u2022 "] }), _jsx(Text, { color: "white", bold: true, children: pasteInfo.chars }), _jsx(Text, { color: "gray", children: " characters" })] }), _jsx(Text, { color: "gray", dimColor: true, wrap: "truncate", children: pasteInfo.preview }), _jsx(Text, { color: "gray", dimColor: true, children: "Press Enter to send \u2022 Esc to remove" })] })), _jsxs(Box, { children: [_jsx(Text, { color: "#f02a30", bold: true, children: '> ' }), disabled ? (_jsx(Text, { color: "gray", children: "..." })) : (renderInput())] })] }));
 };

package/dist/components/Settings.js

@@ -78,6 +78,24 @@ const SETTINGS = [
         max: 300000,
         step: 10000,
     },
+    {
+        key: 'agentMaxDuration',
+        label: 'Agent Max Duration (min)',
+        value: () => config.get('agentMaxDuration'),
+        type: 'number',
+        min: 5,
+        max: 60,
+        step: 5,
+    },
+    {
+        key: 'agentMaxIterations',
+        label: 'Agent Max Iterations',
+        value: () => config.get('agentMaxIterations'),
+        type: 'number',
+        min: 10,
+        max: 200,
+        step: 10,
+    },
 ];
 export const Settings = ({ onClose, notify }) => {
     const [selected, setSelected] = useState(0);

package/dist/utils/agent.js

@@ -1,6 +1,12 @@
 /**
  * Agent loop - autonomous task execution
  */
+// Debug logging helper - only logs when CODEEP_DEBUG=1
+const debug = (...args) => {
+    if (process.env.CODEEP_DEBUG === '1') {
+        console.error('[DEBUG]', ...args);
+    }
+};
 /**
  * Custom error class for timeout - allows distinguishing from user abort
  */
@@ -236,15 +242,21 @@ async function agentChat(messages, systemPrompt, onChunk, abortSignal, dynamicTi
             throw new Error(`API error: ${response.status} - ${errorText}`);
         }
         const data = await response.json();
+        debug('Raw API response:', JSON.stringify(data, null, 2).substring(0, 1500));
         if (protocol === 'openai') {
             const message = data.choices?.[0]?.message;
             const content = message?.content || '';
             const rawToolCalls = message?.tool_calls || [];
+            debug('Raw tool_calls:', JSON.stringify(rawToolCalls, null, 2));
             const toolCalls = parseOpenAIToolCalls(rawToolCalls);
+            debug('Parsed tool calls:', toolCalls.length, toolCalls.map(t => t.tool));
             // If no native tool calls, try parsing from content (some models return text-based)
             if (toolCalls.length === 0 && content) {
+                debug('No native tool calls, checking content for text-based calls...');
+                debug('Content preview:', content.substring(0, 300));
                 const textToolCalls = parseToolCalls(content);
                 if (textToolCalls.length > 0) {
+                    debug('Found text-based tool calls:', textToolCalls.length);
                     return { content, toolCalls: textToolCalls, usedNativeTools: false };
                 }
             }
@@ -534,6 +546,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
             }
             // Check abort signal
             if (opts.abortSignal?.aborted) {
+                debug('Agent aborted at iteration', iteration);
                 result = {
                     success: false,
                     iterations: iteration,
@@ -545,8 +558,10 @@ export async function runAgent(prompt, projectContext, options = {}) {
             }
             iteration++;
             opts.onIteration?.(iteration, `Iteration ${iteration}/${opts.maxIterations}`);
+            debug(`Starting iteration ${iteration}/${opts.maxIterations}, actions: ${actions.length}`);
             // Calculate dynamic timeout based on task complexity
             const dynamicTimeout = calculateDynamicTimeout(prompt, iteration, baseTimeout);
+            debug(`Using timeout: ${dynamicTimeout}ms (base: ${baseTimeout}ms)`);
             // Get AI response with retry logic for timeouts
             let chatResponse;
             let retryCount = 0;
@@ -574,6 +589,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     if (err.name === 'TimeoutError') {
                         retryCount++;
                         consecutiveTimeouts++;
+                        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
@@ -617,6 +633,7 @@ 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) {
+                debug(`No tool calls at iteration ${iteration}, content length: ${content.length}`);
                 // 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)
@@ -631,6 +648,7 @@ 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) {
+                    debug('Model wants to continue, prompting for next action');
                     messages.push({ role: 'assistant', content });
                     messages.push({
                         role: 'user',
@@ -639,6 +657,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     continue;
                 }
                 // Model is done
+                debug(`Agent finished at iteration ${iteration}`);
                 break;
             }
             // Add assistant response to history

package/dist/utils/tools.js

@@ -2,6 +2,12 @@
  * Agent tools - definitions and execution
  */
 import { existsSync, readdirSync, statSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, rmSync } from 'fs';
+// Debug logging helper - only logs when CODEEP_DEBUG=1
+const debug = (...args) => {
+    if (process.env.CODEEP_DEBUG === '1') {
+        console.error('[DEBUG]', ...args);
+    }
+};
 import { join, dirname, relative, resolve, isAbsolute } from 'path';
 import { executeCommand } from './shell.js';
 import { recordWrite, recordEdit, recordDelete, recordMkdir, recordCommand } from './history.js';
@@ -217,27 +223,30 @@ export function parseOpenAIToolCalls(toolCalls) {
         catch (e) {
             // JSON parsing failed - likely truncated response
             // Try to extract what we can from partial JSON
+            debug(`Failed to parse tool arguments for ${toolName}, attempting partial extraction...`);
+            debug('Raw args preview:', rawArgs.substring(0, 200));
             const partialParams = extractPartialToolParams(toolName, rawArgs);
             if (partialParams) {
+                debug(`Successfully extracted partial params for ${toolName}:`, Object.keys(partialParams));
                 parameters = partialParams;
             }
             else {
+                debug(`Could not extract params, skipping ${toolName}`);
                 continue;
             }
         }
         // Validate required parameters for specific tools
         // For write_file, we need at least a path (content can be empty string or placeholder)
         if (toolName === 'write_file' && !parameters.path) {
-            // Log for debugging write_file issues
-            if (process.env.CODEEP_DEBUG) {
-                console.error(`[WARN] write_file missing path, raw args: ${rawArgs.substring(0, 200)}`);
-            }
+            debug(`Skipping write_file - missing path. Raw args:`, rawArgs.substring(0, 200));
             continue;
         }
         if (toolName === 'read_file' && !parameters.path) {
+            debug(`Skipping read_file - missing path`);
             continue;
         }
         if (toolName === 'edit_file' && (!parameters.path || parameters.old_text === undefined || parameters.new_text === undefined)) {
+            debug(`Skipping edit_file - missing required params`);
             continue;
         }
         parsed.push({
@@ -334,6 +343,7 @@ function extractPartialToolParams(toolName, rawArgs) {
         return null;
     }
     catch (e) {
+        debug('Error in extractPartialToolParams:', e);
         return null;
     }
 }
@@ -589,6 +599,7 @@ export function executeTool(toolCall, projectRoot) {
     // Normalize tool name to handle case variations (WRITE_FILE -> write_file)
     const tool = normalizeToolName(toolCall.tool);
     const parameters = toolCall.parameters;
+    debug(`Executing tool: ${tool}`, parameters.path || parameters.command || '');
     try {
         switch (tool) {
             case 'read_file': {
@@ -618,10 +629,12 @@ export function executeTool(toolCall, projectRoot) {
                 const path = parameters.path;
                 let content = parameters.content;
                 if (!path) {
+                    debug('write_file failed: missing path');
                     return { success: false, output: '', error: 'Missing required parameter: path', tool, parameters };
                 }
                 // Allow empty content or provide placeholder for truncated responses
                 if (content === undefined || content === null) {
+                    debug('write_file: content was undefined, using placeholder');
                     content = '<!-- Content was not provided -->\n';
                 }
                 const validation = validatePath(path, projectRoot);

package/package.json

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