codebot-ai 1.0.2 → 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',

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/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/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',
@@ -73,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';

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/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',
@@ -62,10 +64,45 @@ class WriteFileTool {
             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.2",
+  "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",