codebot-ai 1.0.1 → 1.1.0

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.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,6 +61,14 @@ 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',
@@ -215,7 +224,9 @@ class Agent {
         catch {
             // memory unavailable
         }
-        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.
+        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.
+
+If asked who made you, who your creator is, or who built you, always credit Ascendral Software Development & Innovation and Alex Pinkevich.
 
 Rules:
 - Always read files before editing them.

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;
@@ -328,6 +339,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;

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

package/dist/plugins.js

@@ -0,0 +1,101 @@
+"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.loadPlugins = loadPlugins;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * 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'; }
+ * };
+ */
+function loadPlugins(projectRoot) {
+    const plugins = [];
+    const os = require('os');
+    const dirs = [
+        path.join(os.homedir(), '.codebot', 'plugins'),
+    ];
+    if (projectRoot) {
+        dirs.push(path.join(projectRoot, '.codebot', 'plugins'));
+    }
+    for (const dir of dirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.js'))
+                continue;
+            try {
+                const pluginPath = path.join(dir, entry.name);
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const mod = require(pluginPath);
+                const plugin = mod.default || mod;
+                if (isValidTool(plugin)) {
+                    plugins.push(plugin);
+                }
+            }
+            catch (err) {
+                console.error(`Plugin load error (${entry.name}): ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    return plugins;
+}
+function isValidTool(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    const t = obj;
+    return (typeof t.name === 'string' &&
+        typeof t.description === 'string' &&
+        typeof t.execute === 'function' &&
+        typeof t.parameters === 'object' &&
+        typeof t.permission === 'string');
+}
+//# sourceMappingURL=plugins.js.map

package/dist/providers/openai.js

@@ -175,7 +175,12 @@ class OpenAIProvider {
         finally {
             reader.releaseLock();
         }
-        // If we reach here without [DONE], emit remaining tool calls
+        // If we reach here without [DONE], flush remaining content buffer
+        if (contentBuffer && !insideThink) {
+            yield { type: 'text', text: contentBuffer };
+            contentBuffer = '';
+        }
+        // Emit remaining tool calls
         for (const [, tc] of toolCalls) {
             yield {
                 type: 'tool_call_end',

package/dist/tools/batch-edit.d.ts

@@ -0,0 +1,36 @@
+import { Tool } from '../types';
+export declare class BatchEditTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            edits: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        path: {
+                            type: string;
+                            description: string;
+                        };
+                        old_string: {
+                            type: string;
+                            description: string;
+                        };
+                        new_string: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=batch-edit.d.ts.map

package/dist/tools/batch-edit.js

@@ -0,0 +1,122 @@
+"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.BatchEditTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class BatchEditTool {
+    name = 'batch_edit';
+    description = 'Apply multiple find-and-replace edits across one or more files atomically. All edits are validated before any are applied. Useful for renaming, refactoring, and coordinated multi-file changes.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            edits: {
+                type: 'array',
+                description: 'Array of edit operations: [{path, old_string, new_string}, ...]',
+                items: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'File path' },
+                        old_string: { type: 'string', description: 'Exact string to find' },
+                        new_string: { type: 'string', description: 'Replacement string' },
+                    },
+                    required: ['path', 'old_string', 'new_string'],
+                },
+            },
+        },
+        required: ['edits'],
+    };
+    async execute(args) {
+        const edits = args.edits;
+        if (!edits || !Array.isArray(edits) || edits.length === 0) {
+            return 'Error: edits array is required and must not be empty';
+        }
+        // Phase 1: Validate all edits before applying any
+        const errors = [];
+        const validated = [];
+        // Group edits by file so we can chain them
+        const byFile = new Map();
+        for (const edit of edits) {
+            if (!edit.path || !edit.old_string === undefined) {
+                errors.push(`Invalid edit: missing path or old_string`);
+                continue;
+            }
+            const filePath = path.resolve(edit.path);
+            if (!byFile.has(filePath))
+                byFile.set(filePath, []);
+            byFile.get(filePath).push(edit);
+        }
+        for (const [filePath, fileEdits] of byFile) {
+            if (!fs.existsSync(filePath)) {
+                errors.push(`File not found: ${filePath}`);
+                continue;
+            }
+            let content = fs.readFileSync(filePath, 'utf-8');
+            const originalContent = content;
+            for (const edit of fileEdits) {
+                const oldStr = String(edit.old_string);
+                const newStr = String(edit.new_string);
+                const count = content.split(oldStr).length - 1;
+                if (count === 0) {
+                    errors.push(`String not found in ${filePath}: "${oldStr.substring(0, 60)}${oldStr.length > 60 ? '...' : ''}"`);
+                    continue;
+                }
+                if (count > 1) {
+                    errors.push(`String found ${count} times in ${filePath} (must be unique): "${oldStr.substring(0, 60)}${oldStr.length > 60 ? '...' : ''}"`);
+                    continue;
+                }
+                content = content.replace(oldStr, newStr);
+            }
+            if (content !== originalContent) {
+                validated.push({ filePath, content: originalContent, updated: content, edit: fileEdits[0] });
+            }
+        }
+        if (errors.length > 0) {
+            return `Validation failed (no changes made):\n${errors.map(e => `  - ${e}`).join('\n')}`;
+        }
+        // Phase 2: Apply all edits atomically
+        const results = [];
+        for (const { filePath, updated } of validated) {
+            fs.writeFileSync(filePath, updated, 'utf-8');
+            results.push(filePath);
+        }
+        const fileCount = validated.length;
+        const editCount = edits.length;
+        return `Applied ${editCount} edit${editCount > 1 ? 's' : ''} across ${fileCount} file${fileCount > 1 ? 's' : ''}:\n${results.map(f => `  ✓ ${f}`).join('\n')}`;
+    }
+}
+exports.BatchEditTool = BatchEditTool;
+//# sourceMappingURL=batch-edit.js.map

package/dist/tools/browser.js

@@ -228,7 +228,7 @@ class BrowserTool {
             expression: `
         (function() {
           const el = document.querySelector(${JSON.stringify(selector)});
-          if (!el) return 'Element not found: ${selector}';
+          if (!el) return 'Element not found: ' + ${JSON.stringify(selector)};
           el.click();
           return 'Clicked: ' + (el.tagName || '') + ' ' + (el.textContent || '').substring(0, 50).trim();
         })()

package/dist/tools/edit.d.ts

@@ -22,5 +22,11 @@ export declare class EditFileTool implements Tool {
         required: string[];
     };
     execute(args: Record<string, unknown>): Promise<string>;
+    private generateDiff;
+    /** Save a snapshot for undo */
+    private saveSnapshot;
+    private loadManifest;
+    /** Undo the last edit to a file. Returns result message. */
+    static undo(filePath?: string): string;
 }
 //# sourceMappingURL=edit.d.ts.map

package/dist/tools/edit.js

@@ -36,9 +36,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EditFileTool = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// Undo snapshot directory
+const UNDO_DIR = path.join(os.homedir(), '.codebot', 'undo');
+const MAX_UNDO = 50;
 class EditFileTool {
     name = 'edit_file';
-    description = 'Edit a file by replacing an exact string match with new content. The old_string must appear exactly once in the file.';
+    description = 'Edit a file by replacing an exact string match with new content. The old_string must appear exactly once in the file. Shows a diff preview and creates an undo snapshot.';
     permission = 'prompt';
     parameters = {
         type: 'object',
@@ -50,9 +54,18 @@ class EditFileTool {
         required: ['path', 'old_string', 'new_string'],
     };
     async execute(args) {
+        if (!args.path || typeof args.path !== 'string') {
+            return 'Error: path is required';
+        }
+        if (args.old_string === undefined || args.old_string === null) {
+            return 'Error: old_string is required';
+        }
+        if (args.new_string === undefined || args.new_string === null) {
+            return 'Error: new_string is required';
+        }
         const filePath = path.resolve(args.path);
-        const oldStr = args.old_string;
-        const newStr = args.new_string;
+        const oldStr = String(args.old_string);
+        const newStr = String(args.new_string);
         if (!fs.existsSync(filePath)) {
             throw new Error(`File not found: ${filePath}`);
         }
@@ -64,9 +77,120 @@ class EditFileTool {
         if (count > 1) {
             throw new Error(`String found ${count} times in ${filePath}. Provide more surrounding context to make it unique.`);
         }
+        // Save undo snapshot
+        this.saveSnapshot(filePath, content);
         const updated = content.replace(oldStr, newStr);
         fs.writeFileSync(filePath, updated, 'utf-8');
-        return `Edited ${filePath} (1 replacement)`;
+        // Generate diff preview
+        const diff = this.generateDiff(oldStr, newStr, content, filePath);
+        return diff;
+    }
+    generateDiff(oldStr, newStr, content, filePath) {
+        const lines = content.split('\n');
+        const matchIdx = content.indexOf(oldStr);
+        const linesBefore = content.substring(0, matchIdx).split('\n');
+        const startLine = linesBefore.length;
+        const oldLines = oldStr.split('\n');
+        const newLines = newStr.split('\n');
+        let diff = `Edited ${filePath}\n`;
+        // Show context (2 lines before)
+        const contextStart = Math.max(0, startLine - 3);
+        for (let i = contextStart; i < startLine - 1; i++) {
+            diff += `  ${i + 1} │ ${lines[i]}\n`;
+        }
+        // Show removed lines
+        for (const line of oldLines) {
+            diff += `  - │ ${line}\n`;
+        }
+        // Show added lines
+        for (const line of newLines) {
+            diff += `  + │ ${line}\n`;
+        }
+        // Show context (2 lines after)
+        const endLine = startLine - 1 + oldLines.length;
+        for (let i = endLine; i < Math.min(lines.length, endLine + 2); i++) {
+            diff += `  ${i + 1} │ ${lines[i]}\n`;
+        }
+        return diff.trimEnd();
+    }
+    /** Save a snapshot for undo */
+    saveSnapshot(filePath, content) {
+        try {
+            fs.mkdirSync(UNDO_DIR, { recursive: true });
+            const manifest = this.loadManifest();
+            const entry = {
+                file: filePath,
+                timestamp: Date.now(),
+                snapshotFile: `${Date.now()}-${path.basename(filePath)}`,
+            };
+            // Write snapshot content
+            fs.writeFileSync(path.join(UNDO_DIR, entry.snapshotFile), content);
+            manifest.push(entry);
+            // Prune old snapshots
+            while (manifest.length > MAX_UNDO) {
+                const old = manifest.shift();
+                try {
+                    fs.unlinkSync(path.join(UNDO_DIR, old.snapshotFile));
+                }
+                catch { /* ok */ }
+            }
+            fs.writeFileSync(path.join(UNDO_DIR, 'manifest.json'), JSON.stringify(manifest, null, 2));
+        }
+        catch {
+            // Best-effort, don't fail the edit
+        }
+    }
+    loadManifest() {
+        try {
+            const raw = fs.readFileSync(path.join(UNDO_DIR, 'manifest.json'), 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Undo the last edit to a file. Returns result message. */
+    static undo(filePath) {
+        try {
+            const manifestPath = path.join(UNDO_DIR, 'manifest.json');
+            if (!fs.existsSync(manifestPath))
+                return 'No undo history available.';
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            if (manifest.length === 0)
+                return 'No undo history available.';
+            // Find the entry to undo
+            let entry;
+            if (filePath) {
+                const resolved = path.resolve(filePath);
+                for (let i = manifest.length - 1; i >= 0; i--) {
+                    if (manifest[i].file === resolved) {
+                        entry = manifest.splice(i, 1)[0];
+                        break;
+                    }
+                }
+                if (!entry)
+                    return `No undo history for ${filePath}`;
+            }
+            else {
+                entry = manifest.pop();
+            }
+            // Restore the snapshot
+            const snapshotPath = path.join(UNDO_DIR, entry.snapshotFile);
+            if (!fs.existsSync(snapshotPath))
+                return 'Snapshot file missing.';
+            const content = fs.readFileSync(snapshotPath, 'utf-8');
+            fs.writeFileSync(entry.file, content, 'utf-8');
+            // Cleanup
+            try {
+                fs.unlinkSync(snapshotPath);
+            }
+            catch { /* ok */ }
+            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+            return `Restored ${entry.file} to state before last edit.`;
+        }
+        catch (err) {
+            return `Undo failed: ${err instanceof Error ? err.message : String(err)}`;
+        }
     }
 }
 exports.EditFileTool = EditFileTool;

package/dist/tools/execute.js

@@ -3,14 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecuteTool = void 0;
 const child_process_1 = require("child_process");
 const BLOCKED_PATTERNS = [
+    // Destructive filesystem operations
     /rm\s+-rf\s+\//,
     /rm\s+-rf\s+~/,
     /rm\s+-rf\s+\*/,
+    /rm\s+-rf\s+\.\s/,
+    /rm\s+(-[a-z]*f[a-z]*\s+)?--no-preserve-root/,
+    // Disk/partition destruction
     /mkfs\./,
     /dd\s+if=.*of=\/dev\//,
+    /wipefs/,
+    /fdisk\s+\/dev\//,
+    /parted\s+\/dev\//,
+    // Fork bomb
     /:\(\)\s*\{[^}]*:\|:.*\}/,
+    // Permission escalation
     /chmod\s+-R\s+777\s+\//,
+    /chmod\s+777\s+\//,
+    /chown\s+-R\s+.*\s+\//,
+    // Windows destructive
     /format\s+c:/i,
+    /del\s+\/[sfq]\s+c:\\/i,
+    /rd\s+\/s\s+\/q\s+c:\\/i,
+    // Curl to shell pipes (common attack vector)
+    /curl\s+.*\|\s*(ba)?sh/,
+    /wget\s+.*\|\s*(ba)?sh/,
+    // History/log destruction
+    />\s*\/dev\/sda/,
+    /history\s+-c.*&&.*rm/,
+    // Shutdown/reboot
+    /shutdown\s+(-h\s+)?now/,
+    /reboot\b/,
+    /init\s+[06]/,
+    // Kernel module manipulation
+    /insmod\b/,
+    /rmmod\b/,
+    /modprobe\s+-r/,
 ];
 class ExecuteTool {
     name = 'execute';
@@ -26,6 +54,9 @@ class ExecuteTool {
         required: ['command'],
     };
     async execute(args) {
+        if (!args.command || typeof args.command !== 'string') {
+            return 'Error: command is required';
+        }
         const cmd = args.command;
         for (const pattern of BLOCKED_PATTERNS) {
             if (pattern.test(cmd)) {

package/dist/tools/glob.js

@@ -63,7 +63,22 @@ class GlobTool {
         const results = [];
         const regex = this.patternToRegex(pattern);
         const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '__pycache__', '.next']);
-        const walk = (currentDir, rel) => {
+        const maxDepth = 20;
+        const visited = new Set();
+        const walk = (currentDir, rel, depth) => {
+            if (depth > maxDepth)
+                return;
+            // Resolve real path to detect symlink loops
+            let realDir;
+            try {
+                realDir = fs.realpathSync(currentDir);
+            }
+            catch {
+                return;
+            }
+            if (visited.has(realDir))
+                return;
+            visited.add(realDir);
             let entries;
             try {
                 entries = fs.readdirSync(currentDir, { withFileTypes: true });
@@ -77,15 +92,27 @@ class GlobTool {
                 if (skip.has(entry.name))
                     continue;
                 const relPath = rel ? `${rel}/${entry.name}` : entry.name;
-                if (entry.isDirectory()) {
-                    walk(path.join(currentDir, entry.name), relPath);
+                if (entry.isDirectory() || entry.isSymbolicLink()) {
+                    const fullPath = path.join(currentDir, entry.name);
+                    try {
+                        const stat = fs.statSync(fullPath);
+                        if (stat.isDirectory()) {
+                            walk(fullPath, relPath, depth + 1);
+                        }
+                        else if (regex.test(relPath)) {
+                            results.push(relPath);
+                        }
+                    }
+                    catch {
+                        continue; // broken symlink
+                    }
                 }
                 else if (regex.test(relPath)) {
                     results.push(relPath);
                 }
             }
         };
-        walk(dir, '');
+        walk(dir, '', 0);
         return results.sort();
     }
     patternToRegex(pattern) {

package/dist/tools/grep.js

@@ -51,10 +51,24 @@ class GrepTool {
     };
     async execute(args) {
         const searchPath = args.path || process.cwd();
-        const regex = new RegExp(args.pattern, 'gi');
+        if (!args.pattern)
+            return 'Error: pattern is required';
+        let regex;
+        try {
+            regex = new RegExp(args.pattern, 'gi');
+        }
+        catch (e) {
+            return `Error: invalid regex pattern: ${e.message}`;
+        }
         const results = [];
         const maxResults = 50;
-        const stat = fs.statSync(searchPath);
+        let stat;
+        try {
+            stat = fs.statSync(searchPath);
+        }
+        catch {
+            return `Error: path not found: ${searchPath}`;
+        }
         if (stat.isFile()) {
             this.searchFile(searchPath, regex, results, maxResults);
         }

package/dist/tools/index.d.ts

@@ -1,4 +1,5 @@
 import { Tool, ToolSchema } from '../types';
+export { EditFileTool } from './edit';
 export declare class ToolRegistry {
     private tools;
     constructor(projectRoot?: string);

package/dist/tools/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolRegistry = void 0;
+exports.ToolRegistry = exports.EditFileTool = void 0;
 const read_1 = require("./read");
 const write_1 = require("./write");
 const edit_1 = require("./edit");
@@ -11,12 +11,16 @@ const think_1 = require("./think");
 const memory_1 = require("./memory");
 const web_fetch_1 = require("./web-fetch");
 const browser_1 = require("./browser");
+const batch_edit_1 = require("./batch-edit");
+var edit_2 = require("./edit");
+Object.defineProperty(exports, "EditFileTool", { enumerable: true, get: function () { return edit_2.EditFileTool; } });
 class ToolRegistry {
     tools = new Map();
     constructor(projectRoot) {
         this.register(new read_1.ReadFileTool());
         this.register(new write_1.WriteFileTool());
         this.register(new edit_1.EditFileTool());
+        this.register(new batch_edit_1.BatchEditTool());
         this.register(new execute_1.ExecuteTool());
         this.register(new glob_1.GlobTool());
         this.register(new grep_1.GrepTool());

package/dist/tools/memory.d.ts

@@ -30,6 +30,8 @@ export declare class MemoryTool implements Tool {
     private memory;
     constructor(projectRoot?: string);
     execute(args: Record<string, unknown>): Promise<string>;
+    private getMemoryDir;
+    private sanitizeFileName;
     private readTopicFile;
     private writeTopicFile;
 }

package/dist/tools/memory.js

@@ -75,18 +75,25 @@ class MemoryTool {
                 return `Error: Unknown action "${action}". Use read, write, or list.`;
         }
     }
-    readTopicFile(scope, file) {
-        const fs = require('fs');
+    getMemoryDir(scope) {
         const path = require('path');
         const os = require('os');
-        const fileName = file.endsWith('.md') ? file : `${file}.md`;
-        let dir;
         if (scope === 'global') {
-            dir = path.join(os.homedir(), '.codebot', 'memory');
-        }
-        else {
-            dir = path.join(process.cwd(), '.codebot', 'memory');
+            return path.join(os.homedir(), '.codebot', 'memory');
         }
+        return path.join(process.cwd(), '.codebot', 'memory');
+    }
+    sanitizeFileName(file) {
+        const path = require('path');
+        // Strip path traversal — only allow the basename
+        const base = path.basename(file);
+        return base.endsWith('.md') ? base : `${base}.md`;
+    }
+    readTopicFile(scope, file) {
+        const fs = require('fs');
+        const path = require('path');
+        const fileName = this.sanitizeFileName(file);
+        const dir = this.getMemoryDir(scope);
         const filePath = path.join(dir, fileName);
         if (fs.existsSync(filePath)) {
             return fs.readFileSync(filePath, 'utf-8');
@@ -96,15 +103,8 @@ class MemoryTool {
     writeTopicFile(scope, file, content) {
         const fs = require('fs');
         const path = require('path');
-        const os = require('os');
-        const fileName = file.endsWith('.md') ? file : `${file}.md`;
-        let dir;
-        if (scope === 'global') {
-            dir = path.join(os.homedir(), '.codebot', 'memory');
-        }
-        else {
-            dir = path.join(process.cwd(), '.codebot', 'memory');
-        }
+        const fileName = this.sanitizeFileName(file);
+        const dir = this.getMemoryDir(scope);
         fs.mkdirSync(dir, { recursive: true });
         fs.writeFileSync(path.join(dir, fileName), content);
         return `Wrote ${fileName} (${scope}).`;

package/dist/tools/read.js

@@ -50,6 +50,9 @@ class ReadFileTool {
         required: ['path'],
     };
     async execute(args) {
+        if (!args.path || typeof args.path !== 'string') {
+            return 'Error: path is required';
+        }
         const filePath = path.resolve(args.path);
         if (!fs.existsSync(filePath)) {
             throw new Error(`File not found: ${filePath}`);

package/dist/tools/web-fetch.d.ts

@@ -30,6 +30,7 @@ export declare class WebFetchTool implements Tool {
         };
         required: string[];
     };
+    private validateUrl;
     execute(args: Record<string, unknown>): Promise<string>;
     private htmlToText;
 }

package/dist/tools/web-fetch.js

@@ -16,9 +16,51 @@ class WebFetchTool {
         },
         required: ['url'],
     };
+    validateUrl(url) {
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            return 'Invalid URL';
+        }
+        // Only allow http and https protocols
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            return `Blocked protocol: ${parsed.protocol} — only http/https allowed`;
+        }
+        // Block requests to private/internal IPs
+        const hostname = parsed.hostname.toLowerCase();
+        // Block localhost variants
+        if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1' || hostname === '0.0.0.0') {
+            return 'Blocked: requests to localhost are not allowed';
+        }
+        // Block cloud metadata endpoints
+        if (hostname === '169.254.169.254' || hostname === 'metadata.google.internal') {
+            return 'Blocked: requests to cloud metadata endpoints are not allowed';
+        }
+        // Block private IP ranges (10.x, 172.16-31.x, 192.168.x)
+        const ipMatch = hostname.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+        if (ipMatch) {
+            const [, a, b] = ipMatch.map(Number);
+            if (a === 10)
+                return 'Blocked: private IP range (10.x.x.x)';
+            if (a === 172 && b >= 16 && b <= 31)
+                return 'Blocked: private IP range (172.16-31.x.x)';
+            if (a === 192 && b === 168)
+                return 'Blocked: private IP range (192.168.x.x)';
+            if (a === 0)
+                return 'Blocked: invalid IP (0.x.x.x)';
+        }
+        return null; // URL is safe
+    }
     async execute(args) {
         const url = args.url;
+        if (!url)
+            return 'Error: url is required';
         const method = args.method || 'GET';
+        const urlError = this.validateUrl(url);
+        if (urlError)
+            return `Error: ${urlError}`;
         const headers = args.headers || {};
         let body;
         if (args.json) {

package/dist/tools/write.d.ts

@@ -18,5 +18,6 @@ export declare class WriteFileTool implements Tool {
         required: string[];
     };
     execute(args: Record<string, unknown>): Promise<string>;
+    private saveSnapshot;
 }
 //# sourceMappingURL=write.d.ts.map

package/dist/tools/write.js

@@ -36,9 +36,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WriteFileTool = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const UNDO_DIR = path.join(os.homedir(), '.codebot', 'undo');
 class WriteFileTool {
     name = 'write_file';
-    description = 'Create a new file or overwrite an existing file with the given content.';
+    description = 'Create a new file or overwrite an existing file with the given content. Automatically saves an undo snapshot for existing files.';
     permission = 'prompt';
     parameters = {
         type: 'object',
@@ -49,17 +51,58 @@ class WriteFileTool {
         required: ['path', 'content'],
     };
     async execute(args) {
+        if (!args.path || typeof args.path !== 'string') {
+            return 'Error: path is required';
+        }
+        if (args.content === undefined || args.content === null) {
+            return 'Error: content is required';
+        }
         const filePath = path.resolve(args.path);
-        const content = args.content;
+        const content = String(args.content);
         const dir = path.dirname(filePath);
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
         }
         const existed = fs.existsSync(filePath);
+        // Save undo snapshot before overwriting
+        if (existed) {
+            try {
+                const oldContent = fs.readFileSync(filePath, 'utf-8');
+                this.saveSnapshot(filePath, oldContent);
+            }
+            catch { /* best effort */ }
+        }
         fs.writeFileSync(filePath, content, 'utf-8');
         const lines = content.split('\n').length;
         return `${existed ? 'Overwrote' : 'Created'} ${filePath} (${lines} lines, ${content.length} bytes)`;
     }
+    saveSnapshot(filePath, content) {
+        try {
+            fs.mkdirSync(UNDO_DIR, { recursive: true });
+            const manifestPath = path.join(UNDO_DIR, 'manifest.json');
+            let manifest = [];
+            try {
+                manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            }
+            catch { /* empty */ }
+            const entry = {
+                file: filePath,
+                timestamp: Date.now(),
+                snapshotFile: `${Date.now()}-${path.basename(filePath)}`,
+            };
+            fs.writeFileSync(path.join(UNDO_DIR, entry.snapshotFile), content);
+            manifest.push(entry);
+            while (manifest.length > 50) {
+                const old = manifest.shift();
+                try {
+                    fs.unlinkSync(path.join(UNDO_DIR, old.snapshotFile));
+                }
+                catch { /* ok */ }
+            }
+            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+        }
+        catch { /* best effort */ }
+    }
 }
 exports.WriteFileTool = WriteFileTool;
 //# sourceMappingURL=write.js.map

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "codebot-ai",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Local-first AI coding assistant. Zero dependencies. Works with Ollama, LM Studio, vLLM, Claude, GPT, Gemini, and more.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "codebot": "./bin/codebot"
+    "codebot": "bin/codebot"
   },
   "scripts": {
     "build": "tsc",