codebot-ai 1.3.0 → 1.4.1

package/README.md

@@ -107,7 +107,7 @@ echo "explain this error" | codebot            # Pipe mode
 
 ## Tools
 
-CodeBot has 13 built-in tools:
+CodeBot has 28 built-in tools:
 
 | Tool | Description | Permission |
 |------|-------------|-----------|
@@ -124,6 +124,21 @@ CodeBot has 13 built-in tools:
 | `web_search` | Internet search with result summaries | prompt |
 | `browser` | Chrome automation via CDP | prompt |
 | `routine` | Schedule recurring tasks with cron | prompt |
+| `git` | Git operations (status, diff, log, commit, branch, etc.) | prompt |
+| `code_analysis` | Symbol extraction, find references, imports, outline | auto |
+| `multi_search` | Fuzzy search across filenames, content, and symbols | auto |
+| `task_planner` | Hierarchical task tracking with priorities | auto |
+| `diff_viewer` | File comparison and git diffs | auto |
+| `docker` | Container management (ps, run, build, compose) | prompt |
+| `database` | Query SQLite databases (blocks destructive SQL) | prompt |
+| `test_runner` | Auto-detect and run tests (jest, vitest, pytest, go, cargo) | prompt |
+| `http_client` | Advanced HTTP requests with auth and headers | prompt |
+| `image_info` | Image dimensions and metadata (PNG, JPEG, GIF, SVG) | auto |
+| `ssh_remote` | Remote command execution and file transfer via SSH | always-ask |
+| `notification` | Webhook notifications (Slack, Discord, generic) | prompt |
+| `pdf_extract` | Extract text and metadata from PDF files | auto |
+| `package_manager` | Dependency management (npm, yarn, pip, cargo, go) | prompt |
+| `code_review` | Security scanning and complexity analysis | auto |
 
 ### Permission Levels
 

package/dist/agent.js

@@ -38,6 +38,7 @@ const readline = __importStar(require("readline"));
 const tools_1 = require("./tools");
 const parser_1 = require("./parser");
 const manager_1 = require("./context/manager");
+const retry_1 = require("./retry");
 const repo_map_1 = require("./context/repo-map");
 const memory_1 = require("./memory");
 const registry_1 = require("./providers/registry");
@@ -98,6 +99,9 @@ class Agent {
                 yield { type: 'compaction', text: 'Context compacted (summary unavailable).' };
             }
         }
+        // Circuit breaker: track consecutive identical errors
+        let consecutiveErrors = 0;
+        let lastErrorMsg = '';
         for (let i = 0; i < this.maxIterations; i++) {
             // Validate message integrity: ensure every tool_call has a matching tool response
             // This prevents cascading 400 errors from OpenAI when a previous call failed
@@ -136,11 +140,29 @@ class Agent {
                 const msg = err instanceof Error ? err.message : String(err);
                 streamError = `Stream error: ${msg}`;
             }
-            // On error: yield it to the UI but DON'T return — continue to next iteration
             if (streamError) {
                 yield { type: 'error', error: streamError };
+                // Fatal errors (missing API key, auth failure, billing, etc.) — stop immediately
+                if ((0, retry_1.isFatalError)(streamError)) {
+                    return;
+                }
+                // Circuit breaker: stop after 3 consecutive identical errors
+                if (streamError === lastErrorMsg) {
+                    consecutiveErrors++;
+                    if (consecutiveErrors >= 3) {
+                        yield { type: 'error', error: `Same error repeated ${consecutiveErrors} times — stopping. Fix the issue and try again.` };
+                        return;
+                    }
+                }
+                else {
+                    consecutiveErrors = 1;
+                    lastErrorMsg = streamError;
+                }
                 continue;
             }
+            // Reset error tracking on success
+            consecutiveErrors = 0;
+            lastErrorMsg = '';
             // If no native tool calls, try parsing from text
             if (toolCalls.length === 0 && fullText) {
                 toolCalls = (0, parser_1.parseToolCalls)(fullText);

package/dist/cli.js

@@ -44,7 +44,7 @@ const setup_1 = require("./setup");
 const banner_1 = require("./banner");
 const tools_1 = require("./tools");
 const scheduler_1 = require("./scheduler");
-const VERSION = '1.3.0';
+const VERSION = '1.4.1';
 // Session-wide token tracking
 let sessionTokens = { input: 0, output: 0, total: 0 };
 const C = {

package/dist/providers/anthropic.js

@@ -10,6 +10,11 @@ class AnthropicProvider {
         this.name = config.model;
     }
     async *chat(messages, tools) {
+        // Early check: Anthropic always requires an API key
+        if (!this.config.apiKey) {
+            yield { type: 'error', error: `No API key configured for ${this.config.model}. Set ANTHROPIC_API_KEY or run: codebot --setup` };
+            return;
+        }
         const { systemPrompt, apiMessages } = this.convertMessages(messages);
         const body = {
             model: this.config.model,
@@ -66,7 +71,28 @@ class AnthropicProvider {
         }
         if (!response || !response.ok) {
             const text = response ? await response.text().catch(() => '') : '';
-            yield { type: 'error', error: `Anthropic error after retries: ${lastError}${text ? ` — ${text}` : ''}` };
+            // Extract readable error message from JSON response
+            let errorMessage = '';
+            try {
+                const json = JSON.parse(text);
+                errorMessage = json?.error?.message || json?.message || '';
+            }
+            catch {
+                errorMessage = text.substring(0, 200);
+            }
+            const status = response?.status;
+            if (status === 401 || (errorMessage && errorMessage.toLowerCase().includes('api key'))) {
+                yield { type: 'error', error: `Authentication failed (${status}): ${errorMessage || 'Invalid API key'}. Set ANTHROPIC_API_KEY or run: codebot --setup` };
+            }
+            else if (status === 403) {
+                yield { type: 'error', error: `Access denied (403): ${errorMessage || 'Permission denied'}. Check your API key permissions.` };
+            }
+            else if (status === 404) {
+                yield { type: 'error', error: `Model not found (404): ${errorMessage || `"${this.config.model}" may not be available`}.` };
+            }
+            else {
+                yield { type: 'error', error: `Anthropic error (${status || 'unknown'}): ${errorMessage || lastError || 'Unknown error'}` };
+            }
             return;
         }
         if (!response.body) {

package/dist/providers/openai.d.ts

@@ -6,6 +6,10 @@ export declare class OpenAIProvider implements LLMProvider {
     constructor(config: ProviderConfig);
     chat(messages: Message[], tools?: ToolSchema[]): AsyncGenerator<StreamEvent>;
     listModels(): Promise<string[]>;
+    /** Get a helpful hint about which env var to set for the current provider */
+    private getApiKeyHint;
+    /** Format API error responses into readable messages (not raw JSON) */
+    private formatApiError;
     private formatMessage;
 }
 //# sourceMappingURL=openai.d.ts.map

package/dist/providers/openai.js

@@ -13,6 +13,13 @@ class OpenAIProvider {
         this.supportsTools = (0, registry_1.getModelInfo)(config.model).supportsToolCalling;
     }
     async *chat(messages, tools) {
+        const isLocal = this.config.baseUrl.includes('localhost') || this.config.baseUrl.includes('127.0.0.1');
+        // Early check: cloud providers require an API key
+        if (!isLocal && !this.config.apiKey) {
+            const hint = this.getApiKeyHint();
+            yield { type: 'error', error: `No API key configured for ${this.config.model}. ${hint}` };
+            return;
+        }
         const body = {
             model: this.config.model,
             messages: messages.map(m => this.formatMessage(m)),
@@ -22,7 +29,6 @@ class OpenAIProvider {
             body.tools = tools;
         }
         // Ollama/local provider optimizations: set context window and keep model loaded
-        const isLocal = this.config.baseUrl.includes('localhost') || this.config.baseUrl.includes('127.0.0.1');
         if (isLocal) {
             const modelInfo = (0, registry_1.getModelInfo)(this.config.model);
             body.options = { num_ctx: modelInfo.contextWindow };
@@ -69,7 +75,8 @@ class OpenAIProvider {
         }
         if (!response || !response.ok) {
             const text = response ? await response.text().catch(() => '') : '';
-            yield { type: 'error', error: `LLM error after retries: ${lastError}${text ? ` — ${text}` : ''}` };
+            const friendlyError = this.formatApiError(response?.status, text, lastError);
+            yield { type: 'error', error: friendlyError };
             return;
         }
         if (!response.body) {
@@ -240,6 +247,51 @@ class OpenAIProvider {
             return [];
         }
     }
+    /** Get a helpful hint about which env var to set for the current provider */
+    getApiKeyHint() {
+        const url = this.config.baseUrl.toLowerCase();
+        if (url.includes('openai.com'))
+            return 'Set OPENAI_API_KEY or run: codebot --setup';
+        if (url.includes('deepseek'))
+            return 'Set DEEPSEEK_API_KEY or run: codebot --setup';
+        if (url.includes('groq'))
+            return 'Set GROQ_API_KEY or run: codebot --setup';
+        if (url.includes('mistral'))
+            return 'Set MISTRAL_API_KEY or run: codebot --setup';
+        if (url.includes('generativelanguage.googleapis') || url.includes('gemini'))
+            return 'Set GEMINI_API_KEY or run: codebot --setup';
+        if (url.includes('x.ai') || url.includes('grok'))
+            return 'Set XAI_API_KEY or run: codebot --setup';
+        return 'Set your API key or run: codebot --setup';
+    }
+    /** Format API error responses into readable messages (not raw JSON) */
+    formatApiError(status, responseText, lastError) {
+        // Try to extract a useful message from JSON error response
+        let errorMessage = '';
+        try {
+            const json = JSON.parse(responseText);
+            errorMessage = json?.error?.message || json?.message || json?.error || '';
+        }
+        catch {
+            errorMessage = responseText.substring(0, 200);
+        }
+        const hint = this.getApiKeyHint();
+        if (status === 401 || (errorMessage && errorMessage.toLowerCase().includes('api key'))) {
+            return `Authentication failed (${status || 'no status'}): ${errorMessage || 'Invalid or missing API key'}. ${hint}`;
+        }
+        if (status === 403) {
+            return `Access denied (403): ${errorMessage || 'Permission denied'}. Check your API key permissions.`;
+        }
+        if (status === 404) {
+            return `Model not found (404): ${errorMessage || `"${this.config.model}" may not be available`}. Check the model name.`;
+        }
+        if (status === 429) {
+            return `Rate limited (429): ${errorMessage || 'Too many requests'}. Wait a moment and try again.`;
+        }
+        // Generic fallback — still clean, not raw JSON
+        const statusStr = status ? `(${status})` : '';
+        return `LLM error ${statusStr}: ${errorMessage || lastError || 'Unknown error'}`;
+    }
     formatMessage(msg) {
         const formatted = { role: msg.role, content: msg.content };
         if (msg.tool_calls) {

package/dist/retry.d.ts

@@ -18,5 +18,10 @@ export declare function isRetryable(error: unknown, status?: number, opts?: Retr
  */
 export declare function getRetryDelay(attempt: number, retryAfterHeader?: string | null, opts?: RetryOptions): number;
 export declare function sleep(ms: number): Promise<void>;
+/**
+ * Returns true if the error message indicates a fatal/permanent failure
+ * that will never succeed on retry (missing API key, auth failure, billing, etc.).
+ */
+export declare function isFatalError(errorMsg: string): boolean;
 export { DEFAULTS as RETRY_DEFAULTS };
 //# sourceMappingURL=retry.d.ts.map

package/dist/retry.js

@@ -9,6 +9,7 @@ exports.RETRY_DEFAULTS = void 0;
 exports.isRetryable = isRetryable;
 exports.getRetryDelay = getRetryDelay;
 exports.sleep = sleep;
+exports.isFatalError = isFatalError;
 const DEFAULTS = {
     maxRetries: 3,
     baseDelayMs: 1000,
@@ -56,4 +57,27 @@ function getRetryDelay(attempt, retryAfterHeader, opts) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+/**
+ * Returns true if the error message indicates a fatal/permanent failure
+ * that will never succeed on retry (missing API key, auth failure, billing, etc.).
+ */
+function isFatalError(errorMsg) {
+    const lower = errorMsg.toLowerCase();
+    return (lower.includes('api key') ||
+        lower.includes('api_key') ||
+        lower.includes('apikey') ||
+        lower.includes('authentication') ||
+        lower.includes('unauthorized') ||
+        lower.includes('invalid_request_error') ||
+        lower.includes('invalid request') ||
+        lower.includes('permission denied') ||
+        lower.includes('account deactivated') ||
+        lower.includes('account suspended') ||
+        lower.includes('billing') ||
+        (lower.includes('quota') && lower.includes('exceeded')) ||
+        lower.includes('insufficient_quota') ||
+        lower.includes('model not found') ||
+        lower.includes('does not exist') ||
+        lower.includes('access denied'));
+}
 //# sourceMappingURL=retry.js.map

package/dist/tools/code-analysis.d.ts

@@ -0,0 +1,33 @@
+import { Tool } from '../types';
+export declare class CodeAnalysisTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            symbol: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private extractSymbols;
+    private extractImports;
+    private buildOutline;
+    private walkDir;
+    private findReferences;
+    private searchRefs;
+    private readFile;
+}
+//# sourceMappingURL=code-analysis.d.ts.map

package/dist/tools/code-analysis.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeAnalysisTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class CodeAnalysisTool {
+    name = 'code_analysis';
+    description = 'Analyze code structure. Actions: symbols (list classes/functions/exports), imports (list imports), outline (file structure), references (find where a symbol is used).';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: symbols, imports, outline, references' },
+            path: { type: 'string', description: 'File or directory to analyze' },
+            symbol: { type: 'string', description: 'Symbol name to find references for (required for "references" action)' },
+        },
+        required: ['action', 'path'],
+    };
+    async execute(args) {
+        const action = args.action;
+        const targetPath = args.path;
+        if (!action)
+            return 'Error: action is required';
+        if (!targetPath)
+            return 'Error: path is required';
+        if (!fs.existsSync(targetPath)) {
+            return `Error: path not found: ${targetPath}`;
+        }
+        switch (action) {
+            case 'symbols': return this.extractSymbols(targetPath);
+            case 'imports': return this.extractImports(targetPath);
+            case 'outline': return this.buildOutline(targetPath);
+            case 'references': {
+                const symbol = args.symbol;
+                if (!symbol)
+                    return 'Error: symbol is required for references action';
+                return this.findReferences(targetPath, symbol);
+            }
+            default:
+                return `Error: unknown action "${action}". Use: symbols, imports, outline, references`;
+        }
+    }
+    extractSymbols(filePath) {
+        const content = this.readFile(filePath);
+        if (!content)
+            return 'Error: could not read file';
+        const symbols = [];
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNum = i + 1;
+            // Classes
+            const classMatch = line.match(/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/);
+            if (classMatch)
+                symbols.push(`  class ${classMatch[1]} (line ${lineNum})`);
+            // Functions
+            const funcMatch = line.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+            if (funcMatch)
+                symbols.push(`  function ${funcMatch[1]} (line ${lineNum})`);
+            // Arrow function exports
+            const arrowMatch = line.match(/^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+            if (arrowMatch)
+                symbols.push(`  const ${arrowMatch[1]} (line ${lineNum})`);
+            // Interfaces & Types
+            const ifaceMatch = line.match(/^(?:export\s+)?interface\s+(\w+)/);
+            if (ifaceMatch)
+                symbols.push(`  interface ${ifaceMatch[1]} (line ${lineNum})`);
+            const typeMatch = line.match(/^(?:export\s+)?type\s+(\w+)/);
+            if (typeMatch)
+                symbols.push(`  type ${typeMatch[1]} (line ${lineNum})`);
+            // Methods inside classes
+            const methodMatch = line.match(/^\s+(?:async\s+)?(?:private\s+|public\s+|protected\s+)?(\w+)\s*\([^)]*\)\s*[:{]/);
+            if (methodMatch && !['if', 'for', 'while', 'switch', 'catch', 'constructor'].includes(methodMatch[1])) {
+                symbols.push(`    method ${methodMatch[1]} (line ${lineNum})`);
+            }
+        }
+        if (symbols.length === 0)
+            return 'No symbols found.';
+        return `Symbols in ${path.basename(filePath)}:\n${symbols.join('\n')}`;
+    }
+    extractImports(filePath) {
+        const content = this.readFile(filePath);
+        if (!content)
+            return 'Error: could not read file';
+        const imports = [];
+        const lines = content.split('\n');
+        for (const line of lines) {
+            // ES imports
+            const esMatch = line.match(/^import\s+.*from\s+['"]([^'"]+)['"]/);
+            if (esMatch) {
+                imports.push(`  ${esMatch[1]}`);
+                continue;
+            }
+            // Require
+            const reqMatch = line.match(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (reqMatch) {
+                imports.push(`  ${reqMatch[1]}`);
+                continue;
+            }
+            // Python imports
+            const pyMatch = line.match(/^(?:from\s+(\S+)\s+)?import\s+(\S+)/);
+            if (pyMatch && !line.includes('{')) {
+                imports.push(`  ${pyMatch[1] || pyMatch[2]}`);
+            }
+        }
+        if (imports.length === 0)
+            return 'No imports found.';
+        return `Imports in ${path.basename(filePath)}:\n${imports.join('\n')}`;
+    }
+    buildOutline(targetPath) {
+        const stat = fs.statSync(targetPath);
+        if (stat.isFile()) {
+            return this.extractSymbols(targetPath);
+        }
+        // Directory outline
+        const lines = [`Outline of ${path.basename(targetPath)}/`];
+        this.walkDir(targetPath, '', lines, 0, 3);
+        return lines.join('\n');
+    }
+    walkDir(dir, prefix, lines, depth, maxDepth) {
+        if (depth >= maxDepth)
+            return;
+        const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '__pycache__', '.next']);
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const dirs = entries.filter(e => e.isDirectory() && !e.name.startsWith('.') && !skip.has(e.name));
+        const files = entries.filter(e => e.isFile() && !e.name.startsWith('.'));
+        for (const d of dirs.sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`${prefix}${d.name}/`);
+            this.walkDir(path.join(dir, d.name), prefix + '  ', lines, depth + 1, maxDepth);
+        }
+        for (const f of files.sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`${prefix}${f.name}`);
+        }
+    }
+    findReferences(targetPath, symbol) {
+        const stat = fs.statSync(targetPath);
+        const dir = stat.isFile() ? path.dirname(targetPath) : targetPath;
+        const results = [];
+        const regex = new RegExp(`\\b${symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
+        this.searchRefs(dir, regex, results, 50);
+        if (results.length === 0)
+            return `No references to "${symbol}" found.`;
+        return `References to "${symbol}":\n${results.join('\n')}`;
+    }
+    searchRefs(dir, regex, results, max) {
+        if (results.length >= max)
+            return;
+        const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage']);
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (results.length >= max)
+                break;
+            if (entry.name.startsWith('.') || skip.has(entry.name))
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                this.searchRefs(full, regex, results, max);
+            }
+            else {
+                const ext = path.extname(entry.name);
+                if (!['.ts', '.js', '.tsx', '.jsx', '.py', '.go', '.rs', '.java', '.rb', '.c', '.cpp', '.h'].includes(ext))
+                    continue;
+                try {
+                    const content = fs.readFileSync(full, 'utf-8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length && results.length < max; i++) {
+                        regex.lastIndex = 0;
+                        if (regex.test(lines[i])) {
+                            results.push(`  ${full}:${i + 1}: ${lines[i].trimEnd()}`);
+                        }
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    readFile(filePath) {
+        try {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.CodeAnalysisTool = CodeAnalysisTool;
+//# sourceMappingURL=code-analysis.js.map

package/dist/tools/code-review.d.ts

@@ -0,0 +1,32 @@
+import { Tool } from '../types';
+export declare class CodeReviewTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            severity: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private securityScan;
+    private complexityAnalysis;
+    private scanFile;
+    private scanDir;
+    private analyzeFileComplexity;
+    private analyzeDir;
+}
+//# sourceMappingURL=code-review.d.ts.map