codebot-ai 1.0.0

package/dist/tools/edit.js

@@ -0,0 +1,73 @@
+"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.EditFileTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file to edit' },
+            old_string: { type: 'string', description: 'Exact string to find (must be unique in the file)' },
+            new_string: { type: 'string', description: 'Replacement string' },
+        },
+        required: ['path', 'old_string', 'new_string'],
+    };
+    async execute(args) {
+        const filePath = path.resolve(args.path);
+        const oldStr = args.old_string;
+        const newStr = args.new_string;
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const count = content.split(oldStr).length - 1;
+        if (count === 0) {
+            throw new Error(`String not found in ${filePath}. Make sure old_string matches exactly (including whitespace).`);
+        }
+        if (count > 1) {
+            throw new Error(`String found ${count} times in ${filePath}. Provide more surrounding context to make it unique.`);
+        }
+        const updated = content.replace(oldStr, newStr);
+        fs.writeFileSync(filePath, updated, 'utf-8');
+        return `Edited ${filePath} (1 replacement)`;
+    }
+}
+exports.EditFileTool = EditFileTool;
+//# sourceMappingURL=edit.js.map

package/dist/tools/execute.d.ts

@@ -0,0 +1,26 @@
+import { Tool } from '../types';
+export declare class ExecuteTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            command: {
+                type: string;
+                description: string;
+            };
+            cwd: {
+                type: string;
+                description: string;
+            };
+            timeout: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=execute.d.ts.map

package/dist/tools/execute.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteTool = void 0;
+const child_process_1 = require("child_process");
+const BLOCKED_PATTERNS = [
+    /rm\s+-rf\s+\//,
+    /rm\s+-rf\s+~/,
+    /rm\s+-rf\s+\*/,
+    /mkfs\./,
+    /dd\s+if=.*of=\/dev\//,
+    /:\(\)\s*\{[^}]*:\|:.*\}/,
+    /chmod\s+-R\s+777\s+\//,
+    /format\s+c:/i,
+];
+class ExecuteTool {
+    name = 'execute';
+    description = 'Execute a shell command. Returns stdout and stderr. Use for running tests, builds, git commands, etc.';
+    permission = 'always-ask';
+    parameters = {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'Shell command to execute' },
+            cwd: { type: 'string', description: 'Working directory (defaults to current)' },
+            timeout: { type: 'number', description: 'Timeout in ms (default: 30000)' },
+        },
+        required: ['command'],
+    };
+    async execute(args) {
+        const cmd = args.command;
+        for (const pattern of BLOCKED_PATTERNS) {
+            if (pattern.test(cmd)) {
+                throw new Error(`Blocked: "${cmd}" matches a dangerous command pattern.`);
+            }
+        }
+        try {
+            const output = (0, child_process_1.execSync)(cmd, {
+                cwd: args.cwd || process.cwd(),
+                timeout: args.timeout || 30000,
+                maxBuffer: 1024 * 1024,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return output || '(no output)';
+        }
+        catch (err) {
+            const e = err;
+            return `Exit code ${e.status || 1}\nSTDOUT:\n${e.stdout || ''}\nSTDERR:\n${e.stderr || ''}`;
+        }
+    }
+}
+exports.ExecuteTool = ExecuteTool;
+//# sourceMappingURL=execute.js.map

package/dist/tools/glob.d.ts

@@ -0,0 +1,24 @@
+import { Tool } from '../types';
+export declare class GlobTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            pattern: {
+                type: string;
+                description: string;
+            };
+            cwd: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private walkAndMatch;
+    private patternToRegex;
+}
+//# sourceMappingURL=glob.d.ts.map

package/dist/tools/glob.js

@@ -0,0 +1,102 @@
+"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.GlobTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class GlobTool {
+    name = 'glob';
+    description = 'Find files matching a glob pattern. Returns matching file paths relative to the search directory.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Glob pattern (e.g., "**/*.ts", "src/**/*.js")' },
+            cwd: { type: 'string', description: 'Directory to search in (defaults to current)' },
+        },
+        required: ['pattern'],
+    };
+    async execute(args) {
+        const cwd = args.cwd || process.cwd();
+        const pattern = args.pattern;
+        const matches = this.walkAndMatch(cwd, pattern);
+        if (matches.length === 0)
+            return 'No files found matching pattern.';
+        if (matches.length > 100) {
+            return `${matches.slice(0, 100).join('\n')}\n\n... and ${matches.length - 100} more files`;
+        }
+        return matches.join('\n');
+    }
+    walkAndMatch(dir, pattern) {
+        const results = [];
+        const regex = this.patternToRegex(pattern);
+        const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '__pycache__', '.next']);
+        const walk = (currentDir, rel) => {
+            let entries;
+            try {
+                entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') && !pattern.startsWith('.'))
+                    continue;
+                if (skip.has(entry.name))
+                    continue;
+                const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    walk(path.join(currentDir, entry.name), relPath);
+                }
+                else if (regex.test(relPath)) {
+                    results.push(relPath);
+                }
+            }
+        };
+        walk(dir, '');
+        return results.sort();
+    }
+    patternToRegex(pattern) {
+        const regex = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '{{GLOBSTAR}}')
+            .replace(/\*/g, '[^/]*')
+            .replace(/\{\{GLOBSTAR\}\}/g, '.*')
+            .replace(/\?/g, '[^/]');
+        return new RegExp(`^${regex}$`);
+    }
+}
+exports.GlobTool = GlobTool;
+//# sourceMappingURL=glob.js.map

package/dist/tools/grep.d.ts

@@ -0,0 +1,29 @@
+import { Tool } from '../types';
+export declare class GrepTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            pattern: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            include: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private searchFile;
+    private searchDir;
+    private globToRegex;
+}
+//# sourceMappingURL=grep.d.ts.map

package/dist/tools/grep.js

@@ -0,0 +1,125 @@
+"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.GrepTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class GrepTool {
+    name = 'grep';
+    description = 'Search file contents for a regex pattern. Returns matching lines with file paths and line numbers.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Regex pattern to search for' },
+            path: { type: 'string', description: 'File or directory to search (defaults to current directory)' },
+            include: { type: 'string', description: 'File extension filter (e.g., "*.ts", "*.js")' },
+        },
+        required: ['pattern'],
+    };
+    async execute(args) {
+        const searchPath = args.path || process.cwd();
+        const regex = new RegExp(args.pattern, 'gi');
+        const results = [];
+        const maxResults = 50;
+        const stat = fs.statSync(searchPath);
+        if (stat.isFile()) {
+            this.searchFile(searchPath, regex, results, maxResults);
+        }
+        else {
+            this.searchDir(searchPath, regex, results, args.include, maxResults);
+        }
+        if (results.length === 0)
+            return 'No matches found.';
+        const header = results.length >= maxResults ? `(showing first ${maxResults} matches)\n` : '';
+        return header + results.join('\n');
+    }
+    searchFile(filePath, regex, results, maxResults) {
+        if (results.length >= maxResults)
+            return;
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            if (content.includes('\0'))
+                return; // skip binary files
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length && results.length < maxResults; i++) {
+                regex.lastIndex = 0;
+                if (regex.test(lines[i])) {
+                    results.push(`${filePath}:${i + 1}: ${lines[i].trimEnd()}`);
+                }
+            }
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    searchDir(dir, regex, results, include, maxResults) {
+        if (results.length >= maxResults)
+            return;
+        const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '__pycache__']);
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const includeRegex = include ? this.globToRegex(include) : null;
+        for (const entry of entries) {
+            if (results.length >= maxResults)
+                break;
+            if (entry.name.startsWith('.') || skip.has(entry.name))
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                this.searchDir(fullPath, regex, results, include, maxResults);
+            }
+            else {
+                if (includeRegex && !includeRegex.test(entry.name))
+                    continue;
+                this.searchFile(fullPath, regex, results, maxResults);
+            }
+        }
+    }
+    globToRegex(glob) {
+        const regex = glob
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        return new RegExp(`^${regex}$`);
+    }
+}
+exports.GrepTool = GrepTool;
+//# sourceMappingURL=grep.js.map

package/dist/tools/index.d.ts

@@ -0,0 +1,10 @@
+import { Tool, ToolSchema } from '../types';
+export declare class ToolRegistry {
+    private tools;
+    constructor(projectRoot?: string);
+    register(tool: Tool): void;
+    get(name: string): Tool | undefined;
+    getSchemas(): ToolSchema[];
+    all(): Tool[];
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = void 0;
+const read_1 = require("./read");
+const write_1 = require("./write");
+const edit_1 = require("./edit");
+const execute_1 = require("./execute");
+const glob_1 = require("./glob");
+const grep_1 = require("./grep");
+const think_1 = require("./think");
+const memory_1 = require("./memory");
+const web_fetch_1 = require("./web-fetch");
+const browser_1 = require("./browser");
+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 execute_1.ExecuteTool());
+        this.register(new glob_1.GlobTool());
+        this.register(new grep_1.GrepTool());
+        this.register(new think_1.ThinkTool());
+        this.register(new memory_1.MemoryTool(projectRoot));
+        this.register(new web_fetch_1.WebFetchTool());
+        this.register(new browser_1.BrowserTool());
+    }
+    register(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    getSchemas() {
+        return Array.from(this.tools.values()).map(t => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+    }
+    all() {
+        return Array.from(this.tools.values());
+    }
+}
+exports.ToolRegistry = ToolRegistry;
+//# sourceMappingURL=index.js.map

package/dist/tools/memory.d.ts

@@ -0,0 +1,36 @@
+import { Tool } from '../types';
+export declare class MemoryTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            scope: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            file: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    private memory;
+    constructor(projectRoot?: string);
+    execute(args: Record<string, unknown>): Promise<string>;
+    private readTopicFile;
+    private writeTopicFile;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/tools/memory.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryTool = void 0;
+const memory_1 = require("../memory");
+class MemoryTool {
+    name = 'memory';
+    description = 'Read or write persistent memory. Memory survives across sessions and is always available to you. Use this to remember important context, user preferences, project patterns, or anything worth keeping.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                description: 'Action: "read" to view memory, "write" to add/update, "list" to show all files',
+                enum: ['read', 'write', 'list'],
+            },
+            scope: {
+                type: 'string',
+                description: 'Scope: "global" for all projects, "project" for current project',
+                enum: ['global', 'project'],
+            },
+            content: {
+                type: 'string',
+                description: 'Content to write (for write action)',
+            },
+            file: {
+                type: 'string',
+                description: 'Topic file name (e.g., "patterns" creates patterns.md). Omit for main MEMORY.md',
+            },
+        },
+        required: ['action'],
+    };
+    memory;
+    constructor(projectRoot) {
+        this.memory = new memory_1.MemoryManager(projectRoot);
+    }
+    async execute(args) {
+        const action = args.action;
+        const scope = args.scope || 'project';
+        const content = args.content;
+        const file = args.file;
+        switch (action) {
+            case 'read': {
+                if (file) {
+                    return this.readTopicFile(scope, file);
+                }
+                const result = scope === 'global'
+                    ? this.memory.readGlobal()
+                    : this.memory.readProject();
+                return result || '(empty — no memory saved yet)';
+            }
+            case 'write': {
+                if (!content)
+                    return 'Error: content is required for write action';
+                if (file) {
+                    return this.writeTopicFile(scope, file, content);
+                }
+                if (scope === 'global') {
+                    this.memory.appendGlobal(content);
+                }
+                else {
+                    this.memory.appendProject(content);
+                }
+                return `Memory updated (${scope}).`;
+            }
+            case 'list': {
+                const files = this.memory.list();
+                if (files.length === 0)
+                    return 'No memory files yet.';
+                return files
+                    .map(f => `[${f.scope}] ${f.file} (${f.size} bytes)`)
+                    .join('\n');
+            }
+            default:
+                return `Error: Unknown action "${action}". Use read, write, or list.`;
+        }
+    }
+    readTopicFile(scope, file) {
+        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 filePath = path.join(dir, fileName);
+        if (fs.existsSync(filePath)) {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        return `(no file: ${fileName})`;
+    }
+    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');
+        }
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, fileName), content);
+        return `Wrote ${fileName} (${scope}).`;
+    }
+}
+exports.MemoryTool = MemoryTool;
+//# sourceMappingURL=memory.js.map

package/dist/tools/read.d.ts

@@ -0,0 +1,26 @@
+import { Tool } from '../types';
+export declare class ReadFileTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            offset: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=read.d.ts.map