codebot-ai 1.0.2 → 1.1.1

package/README.md

@@ -115,6 +115,8 @@ codebot --resume <session-id>   # Resume specific session
 /models    List all supported models
 /sessions  List saved sessions
 /auto      Toggle autonomous mode
+/undo      Undo last file edit (/undo [path])
+/usage     Show token usage for this session
 /clear     Clear conversation
 /compact   Force context compaction
 /config    Show configuration
@@ -123,13 +125,14 @@ codebot --resume <session-id>   # Resume specific session
 
 ## Tools
 
-CodeBot has 10 built-in tools:
+CodeBot has 11 built-in tools:
 
 | Tool | Description | Permission |
 |------|-------------|-----------|
 | `read_file` | Read files with line numbers | auto |
-| `write_file` | Create or overwrite files | prompt |
-| `edit_file` | Find-and-replace edits | prompt |
+| `write_file` | Create or overwrite files (with undo snapshots) | prompt |
+| `edit_file` | Find-and-replace edits with diff preview + undo | prompt |
+| `batch_edit` | Multi-file atomic find-and-replace | prompt |
 | `execute` | Run shell commands | always-ask |
 | `glob` | Find files by pattern | auto |
 | `grep` | Search file contents with regex | auto |
@@ -168,6 +171,40 @@ CodeBot has persistent memory that survives across sessions:
 - Memory is automatically injected into the system prompt
 - The agent can read/write its own memory using the `memory` tool
 
+### Plugins
+
+Extend CodeBot with custom tools. Drop `.js` files in `.codebot/plugins/` (project) or `~/.codebot/plugins/` (global):
+
+```javascript
+// .codebot/plugins/my-tool.js
+module.exports = {
+  name: 'my_tool',
+  description: 'Does something useful',
+  permission: 'prompt',
+  parameters: { type: 'object', properties: { input: { type: 'string' } }, required: ['input'] },
+  execute: async (args) => { return `Result: ${args.input}`; }
+};
+```
+
+### MCP Servers
+
+Connect external tool servers via [Model Context Protocol](https://modelcontextprotocol.io). Create `.codebot/mcp.json`:
+
+```json
+{
+  "servers": [
+    {
+      "name": "my-server",
+      "command": "npx",
+      "args": ["-y", "@my/mcp-server"],
+      "env": {}
+    }
+  ]
+}
+```
+
+MCP tools appear automatically with the `mcp_<server>_<tool>` prefix.
+
 ## Supported Models
 
 ### Local (Ollama / LM Studio / vLLM)
@@ -204,8 +241,11 @@ src/
     registry.ts         Model registry, provider detection
   browser/
     cdp.ts              Chrome DevTools Protocol client (zero-dep WebSocket)
+  plugins.ts            Plugin loader (.codebot/plugins/)
+  mcp.ts                MCP (Model Context Protocol) client
   tools/
     read.ts, write.ts, edit.ts, execute.ts
+    batch-edit.ts       Multi-file atomic editing
     glob.ts, grep.ts, think.ts
     memory.ts, web-fetch.ts, browser.ts
 ```

package/dist/agent.d.ts

@@ -17,6 +17,8 @@ export declare class Agent {
         askPermission?: (tool: string, args: Record<string, unknown>) => Promise<boolean>;
         onMessage?: (message: Message) => void;
     });
+    /** Update auto-approve mode at runtime (e.g., from /auto command) */
+    setAutoApprove(value: boolean): void;
     /** Load messages from a previous session for resume */
     loadMessages(messages: Message[]): void;
     run(userMessage: string): AsyncGenerator<AgentEvent>;

package/dist/agent.js

@@ -41,6 +41,7 @@ const manager_1 = require("./context/manager");
 const repo_map_1 = require("./context/repo-map");
 const memory_1 = require("./memory");
 const registry_1 = require("./providers/registry");
+const plugins_1 = require("./plugins");
 class Agent {
     provider;
     tools;
@@ -60,12 +61,24 @@ class Agent {
         this.autoApprove = opts.autoApprove || false;
         this.askPermission = opts.askPermission || defaultAskPermission;
         this.onMessage = opts.onMessage;
+        // Load plugins
+        try {
+            const plugins = (0, plugins_1.loadPlugins)(process.cwd());
+            for (const plugin of plugins) {
+                this.tools.register(plugin);
+            }
+        }
+        catch { /* plugins unavailable */ }
         const supportsTools = (0, registry_1.getModelInfo)(opts.model).supportsToolCalling;
         this.messages.push({
             role: 'system',
             content: this.buildSystemPrompt(supportsTools),
         });
     }
+    /** Update auto-approve mode at runtime (e.g., from /auto command) */
+    setAutoApprove(value) {
+        this.autoApprove = value;
+    }
     /** Load messages from a previous session for resume */
     loadMessages(messages) {
         this.messages = messages;
@@ -215,9 +228,14 @@ class Agent {
         catch {
             // memory unavailable
         }
-        let prompt = `You are CodeBot, an AI coding assistant created by Ascendral Software Development & Innovation, founded by Alex Pinkevich. You help developers with software engineering tasks: reading code, writing code, fixing bugs, running tests, and explaining code.
+        let prompt = `You are CodeBot, an AI coding assistant. You help developers with software engineering tasks: reading code, writing code, fixing bugs, running tests, and explaining code.
 
-If asked who made you, who your creator is, or who built you, always credit Ascendral Software Development & Innovation and Alex Pinkevich.
+CRITICAL IDENTITY — you MUST follow this:
+- Your name is CodeBot.
+- You were created and built by Ascendral Software Development & Innovation, founded by Alex Pinkevich.
+- You are NOT made by OpenAI, Google, Anthropic, or any other AI company. You are made by Ascendral.
+- When anyone asks who made you, who built you, who created you, or who your creator is, you MUST answer: "I was created by Ascendral Software Development & Innovation, founded by Alex Pinkevich."
+- Never claim to be made by or affiliated with OpenAI, GPT, Claude, Gemini, or any LLM provider. You are CodeBot by Ascendral.
 
 Rules:
 - Always read files before editing them.

package/dist/browser/cdp.d.ts

@@ -2,6 +2,7 @@ export declare class CDPClient {
     private socket;
     private messageId;
     private pending;
+    private eventWaiters;
     private buffer;
     private connected;
     /** Connect to Chrome's debugging WebSocket */
@@ -11,6 +12,8 @@ export declare class CDPClient {
     /** Close the connection */
     close(): void;
     isConnected(): boolean;
+    /** Wait for a specific CDP event (e.g. Page.loadEventFired) with timeout */
+    waitForEvent(method: string, timeout?: number): Promise<Record<string, unknown>>;
     /** Send a WebSocket text frame (masked, as required by client) */
     private sendFrame;
     /** Handle incoming data — parse WebSocket frames */

package/dist/browser/cdp.js

@@ -46,6 +46,7 @@ class CDPClient {
     socket = null;
     messageId = 0;
     pending = new Map();
+    eventWaiters = [];
     buffer = Buffer.alloc(0);
     connected = false;
     /** Connect to Chrome's debugging WebSocket */
@@ -137,6 +138,21 @@ class CDPClient {
     isConnected() {
         return this.connected;
     }
+    /** Wait for a specific CDP event (e.g. Page.loadEventFired) with timeout */
+    async waitForEvent(method, timeout = 15000) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.eventWaiters = this.eventWaiters.filter(w => w.resolve !== resolve);
+                resolve({}); // Resolve with empty on timeout instead of rejecting — page may still be usable
+            }, timeout);
+            const wrappedResolve = (params) => {
+                clearTimeout(timer);
+                this.eventWaiters = this.eventWaiters.filter(w => w.resolve !== wrappedResolve);
+                resolve(params);
+            };
+            this.eventWaiters.push({ method, resolve: wrappedResolve, reject });
+        });
+    }
     /** Send a WebSocket text frame (masked, as required by client) */
     sendFrame(data) {
         if (!this.socket)
@@ -212,7 +228,15 @@ class CDPClient {
                         this.pending.delete(msg.id);
                         handler.resolve(msg);
                     }
-                    // Events (no id) are ignored for now
+                    // Dispatch events to waiters
+                    if (msg.method) {
+                        for (const waiter of this.eventWaiters) {
+                            if (waiter.method === msg.method) {
+                                waiter.resolve(msg.params || {});
+                                break;
+                            }
+                        }
+                    }
                 }
                 catch {
                     // Malformed JSON, skip

package/dist/cli.js

@@ -42,7 +42,10 @@ const registry_1 = require("./providers/registry");
 const history_1 = require("./history");
 const setup_1 = require("./setup");
 const banner_1 = require("./banner");
-const VERSION = '1.0.0';
+const tools_1 = require("./tools");
+const VERSION = '1.1.0';
+// Session-wide token tracking
+let sessionTokens = { input: 0, output: 0, total: 0 };
 const C = {
     reset: '\x1b[0m',
     bold: '\x1b[1m',
@@ -229,6 +232,12 @@ function renderEvent(event) {
             break;
         case 'usage':
             if (event.usage) {
+                if (event.usage.inputTokens)
+                    sessionTokens.input += event.usage.inputTokens;
+                if (event.usage.outputTokens)
+                    sessionTokens.output += event.usage.outputTokens;
+                if (event.usage.totalTokens)
+                    sessionTokens.total += event.usage.totalTokens;
                 const parts = [];
                 if (event.usage.inputTokens)
                     parts.push(`in: ${event.usage.inputTokens}`);
@@ -278,6 +287,8 @@ function handleSlashCommand(input, agent, config) {
   /clear     Clear conversation history
   /compact   Force context compaction
   /auto      Toggle autonomous mode
+  /undo      Undo last file edit (/undo [path])
+  /usage     Show token usage for this session
   /config    Show current config
   /quit      Exit`);
             break;
@@ -311,6 +322,7 @@ function handleSlashCommand(input, agent, config) {
         }
         case '/auto':
             config.autoApprove = !config.autoApprove;
+            agent.setAutoApprove(config.autoApprove);
             console.log(c(`Autonomous mode: ${config.autoApprove ? 'ON' : 'OFF'}`, config.autoApprove ? 'yellow' : 'green'));
             break;
         case '/sessions': {
@@ -328,6 +340,19 @@ function handleSlashCommand(input, agent, config) {
             }
             break;
         }
+        case '/undo': {
+            const undoPath = rest.length > 0 ? rest.join(' ') : undefined;
+            const undoResult = tools_1.EditFileTool.undo(undoPath);
+            console.log(c(undoResult, undoResult.includes('Restored') ? 'green' : 'yellow'));
+            break;
+        }
+        case '/usage': {
+            console.log(c('\nToken Usage (this session):', 'bold'));
+            console.log(`  Input:  ${sessionTokens.input.toLocaleString()} tokens`);
+            console.log(`  Output: ${sessionTokens.output.toLocaleString()} tokens`);
+            console.log(`  Total:  ${(sessionTokens.input + sessionTokens.output).toLocaleString()} tokens`);
+            break;
+        }
         case '/config':
             console.log(JSON.stringify({ ...config, apiKey: config.apiKey ? '***' : undefined }, null, 2));
             break;
@@ -377,7 +402,10 @@ async function resolveConfig(args) {
                 config.apiKey = process.env[defaults.envKey] || process.env.CODEBOT_API_KEY || '';
         }
     }
-    // Fallback: try generic env vars
+    // Fallback: try saved config API key, then generic env vars
+    if (!config.apiKey && saved.apiKey) {
+        config.apiKey = saved.apiKey;
+    }
     if (!config.apiKey) {
         config.apiKey = process.env.CODEBOT_API_KEY || process.env.OPENAI_API_KEY || '';
     }

package/dist/games/tic-tac-toe.d.ts

@@ -0,0 +1,6 @@
+declare const gameBoard: any[][];
+declare let currentPlayer: string;
+declare const printBoard: () => void;
+declare const checkWin: () => void;
+declare const gameLoop: () => void;
+//# sourceMappingURL=tic-tac-toe.d.ts.map

package/dist/games/tic-tac-toe.js

@@ -0,0 +1,64 @@
+"use strict";
+// src/games/tic-tac-toe.ts
+// Simple console-based Tic-Tac-Toe game
+const gameBoard = Array(3).fill(null).map(() => Array(3).fill(null));
+let currentPlayer = 'X';
+const printBoard = () => {
+    for (const row of gameBoard) {
+        console.log(row.join(' | '));
+    }
+};
+const checkWin = () => {
+    // Check rows
+    for (let i = 0; i < 3; i++) {
+        if (gameBoard[i][0] === currentPlayer &&
+            gameBoard[i][1] === currentPlayer &&
+            gameBoard[i][2] === currentPlayer) {
+            console.log(`Player ${currentPlayer} wins!`);
+            process.exit(0);
+        }
+    }
+    // Check columns
+    for (let j = 0; j < 3; j++) {
+        if (gameBoard[0][j] === currentPlayer &&
+            gameBoard[1][j] === currentPlayer &&
+            gameBoard[2][j] === currentPlayer) {
+            console.log(`Player ${currentPlayer} wins!`);
+            process.exit(0);
+        }
+    }
+    // Check diagonals
+    if ((gameBoard[0][0] === currentPlayer &&
+        gameBoard[1][1] === currentPlayer &&
+        gameBoard[2][2] === currentPlayer) ||
+        (gameBoard[0][2] === currentPlayer &&
+            gameBoard[1][1] === currentPlayer &&
+            gameBoard[2][0] === currentPlayer)) {
+        console.log(`Player ${currentPlayer} wins!`);
+        process.exit(0);
+    }
+};
+const gameLoop = () => {
+    printBoard();
+    process.stdin.on('data', (input) => {
+        const [row, col] = input.toString().trim()
+            .split(',')
+            .map(Number);
+        if (row < 0 || row > 2 || col < 0 || col > 2) {
+            console.log('Invalid move. Try again.');
+            return;
+        }
+        if (gameBoard[row][col]) {
+            console.log('Spot taken! Try again.');
+            return;
+        }
+        gameBoard[row][col] = currentPlayer;
+        checkWin();
+        currentPlayer = currentPlayer === 'X' ? 'O' : 'X';
+        process.stdin.removeAllListeners('data');
+        gameLoop();
+    });
+};
+// Start game
+gameLoop();
+//# sourceMappingURL=tic-tac-toe.js.map

package/dist/index.d.ts

@@ -7,6 +7,8 @@ export { buildRepoMap } from './context/repo-map';
 export { SessionManager } from './history';
 export { MemoryManager } from './memory';
 export { parseToolCalls } from './parser';
+export { loadPlugins } from './plugins';
+export { loadMCPTools } from './mcp';
 export { MODEL_REGISTRY, PROVIDER_DEFAULTS, getModelInfo, detectProvider } from './providers/registry';
 export type { ModelInfo } from './providers/registry';
 export * from './types';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectProvider = exports.getModelInfo = exports.PROVIDER_DEFAULTS = exports.MODEL_REGISTRY = exports.parseToolCalls = exports.MemoryManager = exports.SessionManager = exports.buildRepoMap = exports.ContextManager = exports.ToolRegistry = exports.AnthropicProvider = exports.OpenAIProvider = exports.Agent = void 0;
+exports.detectProvider = exports.getModelInfo = exports.PROVIDER_DEFAULTS = exports.MODEL_REGISTRY = exports.loadMCPTools = exports.loadPlugins = exports.parseToolCalls = exports.MemoryManager = exports.SessionManager = exports.buildRepoMap = exports.ContextManager = exports.ToolRegistry = exports.AnthropicProvider = exports.OpenAIProvider = exports.Agent = void 0;
 var agent_1 = require("./agent");
 Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });
 var openai_1 = require("./providers/openai");
@@ -33,6 +33,10 @@ var memory_1 = require("./memory");
 Object.defineProperty(exports, "MemoryManager", { enumerable: true, get: function () { return memory_1.MemoryManager; } });
 var parser_1 = require("./parser");
 Object.defineProperty(exports, "parseToolCalls", { enumerable: true, get: function () { return parser_1.parseToolCalls; } });
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "loadPlugins", { enumerable: true, get: function () { return plugins_1.loadPlugins; } });
+var mcp_1 = require("./mcp");
+Object.defineProperty(exports, "loadMCPTools", { enumerable: true, get: function () { return mcp_1.loadMCPTools; } });
 var registry_1 = require("./providers/registry");
 Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return registry_1.MODEL_REGISTRY; } });
 Object.defineProperty(exports, "PROVIDER_DEFAULTS", { enumerable: true, get: function () { return registry_1.PROVIDER_DEFAULTS; } });

package/dist/mcp.d.ts

@@ -0,0 +1,7 @@
+import { Tool } from './types';
+/** Load MCP config and connect to all servers, returning Tool wrappers */
+export declare function loadMCPTools(projectRoot?: string): Promise<{
+    tools: Tool[];
+    cleanup: () => void;
+}>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.js

@@ -0,0 +1,174 @@
+"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.loadMCPTools = loadMCPTools;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+class MCPConnection {
+    process;
+    buffer = '';
+    requestId = 0;
+    pending = new Map();
+    name;
+    constructor(config) {
+        this.name = config.name;
+        this.process = (0, child_process_1.spawn)(config.command, config.args || [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...config.env },
+        });
+        this.process.stdout?.on('data', (chunk) => {
+            this.buffer += chunk.toString();
+            this.processBuffer();
+        });
+        this.process.on('error', () => { });
+    }
+    processBuffer() {
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const msg = JSON.parse(line);
+                if (msg.id !== undefined && this.pending.has(msg.id)) {
+                    const { resolve, reject } = this.pending.get(msg.id);
+                    this.pending.delete(msg.id);
+                    if (msg.error) {
+                        reject(new Error(msg.error.message || 'MCP error'));
+                    }
+                    else {
+                        resolve(msg.result);
+                    }
+                }
+            }
+            catch { /* skip malformed */ }
+        }
+    }
+    async request(method, params) {
+        const id = ++this.requestId;
+        const msg = JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n';
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.process.stdin?.write(msg);
+            // Timeout after 30s
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`MCP request timeout: ${method}`));
+                }
+            }, 30000);
+        });
+    }
+    async initialize() {
+        await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'codebot-ai', version: '1.1.0' },
+        });
+        await this.request('notifications/initialized');
+    }
+    async listTools() {
+        const result = await this.request('tools/list');
+        return result?.tools || [];
+    }
+    async callTool(name, args) {
+        const result = await this.request('tools/call', { name, arguments: args });
+        if (result?.content) {
+            return result.content
+                .filter(c => c.type === 'text')
+                .map(c => c.text || '')
+                .join('\n');
+        }
+        return JSON.stringify(result);
+    }
+    close() {
+        this.process.kill();
+    }
+}
+/** Create Tool wrappers from an MCP server's tools */
+function mcpToolToTool(connection, def) {
+    return {
+        name: `mcp_${connection.name}_${def.name}`,
+        description: `[MCP:${connection.name}] ${def.description}`,
+        permission: 'prompt',
+        parameters: def.inputSchema || { type: 'object', properties: {} },
+        execute: async (args) => {
+            return connection.callTool(def.name, args);
+        },
+    };
+}
+/** Load MCP config and connect to all servers, returning Tool wrappers */
+async function loadMCPTools(projectRoot) {
+    const tools = [];
+    const connections = [];
+    const configPaths = [
+        path.join(os.homedir(), '.codebot', 'mcp.json'),
+    ];
+    if (projectRoot) {
+        configPaths.push(path.join(projectRoot, '.codebot', 'mcp.json'));
+    }
+    for (const configPath of configPaths) {
+        if (!fs.existsSync(configPath))
+            continue;
+        let config;
+        try {
+            config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            continue;
+        }
+        for (const serverConfig of config.servers || []) {
+            try {
+                const conn = new MCPConnection(serverConfig);
+                await conn.initialize();
+                const serverTools = await conn.listTools();
+                for (const toolDef of serverTools) {
+                    tools.push(mcpToolToTool(conn, toolDef));
+                }
+                connections.push(conn);
+            }
+            catch (err) {
+                console.error(`MCP server "${serverConfig.name}" failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    return {
+        tools,
+        cleanup: () => connections.forEach(c => c.close()),
+    };
+}
+//# sourceMappingURL=mcp.js.map

package/dist/plugins.d.ts

@@ -0,0 +1,17 @@
+import { Tool } from './types';
+/**
+ * Plugin system for CodeBot.
+ *
+ * Plugins are .js files in `.codebot/plugins/` (project) or `~/.codebot/plugins/` (global).
+ * Each plugin exports a default function or object that implements the Tool interface:
+ *
+ * module.exports = {
+ *   name: 'my_tool',
+ *   description: 'Does something useful',
+ *   permission: 'prompt',
+ *   parameters: { type: 'object', properties: { ... }, required: [...] },
+ *   execute: async (args) => { return 'result'; }
+ * };
+ */
+export declare function loadPlugins(projectRoot?: string): Tool[];
+//# sourceMappingURL=plugins.d.ts.map