codebot-ai 1.3.0 → 1.4.1

package/dist/tools/pdf-extract.js

@@ -0,0 +1,178 @@
+"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.PdfExtractTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class PdfExtractTool {
+    name = 'pdf_extract';
+    description = 'Extract text and metadata from PDF files. Actions: text, info, pages.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: text (extract text), info (file info), pages (page count)' },
+            path: { type: 'string', description: 'Path to PDF file' },
+            max_pages: { type: 'number', description: 'Max pages to extract (default: 10)' },
+        },
+        required: ['action', 'path'],
+    };
+    async execute(args) {
+        const action = args.action;
+        const filePath = args.path;
+        if (!action)
+            return 'Error: action is required';
+        if (!filePath)
+            return 'Error: path is required';
+        if (!fs.existsSync(filePath))
+            return `Error: file not found: ${filePath}`;
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext !== '.pdf')
+            return `Error: not a PDF file (got ${ext})`;
+        switch (action) {
+            case 'text': return this.extractText(filePath, args);
+            case 'info': return this.getInfo(filePath);
+            case 'pages': return this.countPages(filePath);
+            default: return `Error: unknown action "${action}". Use: text, info, pages`;
+        }
+    }
+    extractText(filePath, args) {
+        const maxPages = args.max_pages || 10;
+        try {
+            const content = fs.readFileSync(filePath);
+            const text = this.extractFromBuffer(content, maxPages);
+            if (!text.trim()) {
+                return 'No extractable text found. The PDF may contain scanned images or use non-standard encoding.';
+            }
+            return `Extracted text from ${path.basename(filePath)}:\n\n${text}`;
+        }
+        catch (err) {
+            return `Error: ${err instanceof Error ? err.message : 'failed to read PDF'}`;
+        }
+    }
+    getInfo(filePath) {
+        const stat = fs.statSync(filePath);
+        const sizeMB = (stat.size / (1024 * 1024)).toFixed(2);
+        const content = fs.readFileSync(filePath);
+        const pages = this.estimatePageCount(content);
+        // Extract PDF metadata
+        const text = content.toString('latin1');
+        const title = this.extractMeta(text, 'Title');
+        const author = this.extractMeta(text, 'Author');
+        const creator = this.extractMeta(text, 'Creator');
+        let result = `File: ${path.basename(filePath)}\nSize: ${sizeMB} MB\nPages: ~${pages}\nModified: ${stat.mtime.toISOString()}`;
+        if (title)
+            result += `\nTitle: ${title}`;
+        if (author)
+            result += `\nAuthor: ${author}`;
+        if (creator)
+            result += `\nCreator: ${creator}`;
+        return result;
+    }
+    countPages(filePath) {
+        const content = fs.readFileSync(filePath);
+        const pages = this.estimatePageCount(content);
+        return `${path.basename(filePath)}: approximately ${pages} page(s)`;
+    }
+    estimatePageCount(buf) {
+        // Count /Type /Page occurrences (not /Pages)
+        const text = buf.toString('latin1');
+        const matches = text.match(/\/Type\s*\/Page(?!\s*s)/g);
+        return matches ? matches.length : 1;
+    }
+    extractFromBuffer(buf, maxPages) {
+        // Simple text extraction — find text between BT/ET markers and decode
+        const text = buf.toString('latin1');
+        const chunks = [];
+        let pageCount = 0;
+        // Find stream content
+        const streamRegex = /stream\r?\n([\s\S]*?)endstream/g;
+        let match;
+        while ((match = streamRegex.exec(text)) !== null && pageCount < maxPages) {
+            const stream = match[1];
+            // Extract text from BT...ET blocks
+            const btRegex = /BT\s([\s\S]*?)ET/g;
+            let btMatch;
+            while ((btMatch = btRegex.exec(stream)) !== null) {
+                const block = btMatch[1];
+                // Extract text strings in parentheses: (Hello World) Tj
+                const tjRegex = /\(([^)]*)\)\s*Tj/g;
+                let tjMatch;
+                while ((tjMatch = tjRegex.exec(block)) !== null) {
+                    const decoded = this.decodePdfString(tjMatch[1]);
+                    if (decoded.trim())
+                        chunks.push(decoded);
+                }
+                // Extract TJ arrays: [(text1) 10 (text2)] TJ
+                const tjArrayRegex = /\[(.*?)\]\s*TJ/g;
+                let arrMatch;
+                while ((arrMatch = tjArrayRegex.exec(block)) !== null) {
+                    const inner = arrMatch[1];
+                    const strRegex = /\(([^)]*)\)/g;
+                    let strMatch;
+                    const parts = [];
+                    while ((strMatch = strRegex.exec(inner)) !== null) {
+                        parts.push(this.decodePdfString(strMatch[1]));
+                    }
+                    if (parts.length > 0)
+                        chunks.push(parts.join(''));
+                }
+            }
+            if (chunks.length > 0)
+                pageCount++;
+        }
+        // Clean up and join
+        return chunks
+            .map(c => c.trim())
+            .filter(c => c.length > 0)
+            .join('\n')
+            .substring(0, 20_000);
+    }
+    decodePdfString(s) {
+        return s
+            .replace(/\\n/g, '\n')
+            .replace(/\\r/g, '\r')
+            .replace(/\\t/g, '\t')
+            .replace(/\\\\/g, '\\')
+            .replace(/\\([()])/g, '$1');
+    }
+    extractMeta(text, key) {
+        const regex = new RegExp(`/${key}\\s*\\(([^)]*)\\)`);
+        const match = text.match(regex);
+        return match ? match[1] : null;
+    }
+}
+exports.PdfExtractTool = PdfExtractTool;
+//# sourceMappingURL=pdf-extract.js.map

package/dist/tools/ssh-remote.d.ts

@@ -0,0 +1,39 @@
+import { Tool } from '../types';
+export declare class SshRemoteTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            host: {
+                type: string;
+                description: string;
+            };
+            command: {
+                type: string;
+                description: string;
+            };
+            local_path: {
+                type: string;
+                description: string;
+            };
+            remote_path: {
+                type: string;
+                description: string;
+            };
+            port: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private runSsh;
+}
+//# sourceMappingURL=ssh-remote.d.ts.map

package/dist/tools/ssh-remote.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SshRemoteTool = void 0;
+const child_process_1 = require("child_process");
+// Block shell injection characters in host/user inputs
+const SAFE_HOST = /^[a-zA-Z0-9._\-@:]+$/;
+class SshRemoteTool {
+    name = 'ssh_remote';
+    description = 'Execute commands on remote servers via SSH, or upload/download files via SCP. Actions: exec, upload, download.';
+    permission = 'always-ask';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: exec, upload, download' },
+            host: { type: 'string', description: 'SSH target (user@hostname or hostname)' },
+            command: { type: 'string', description: 'Command to execute remotely (for exec)' },
+            local_path: { type: 'string', description: 'Local file path (for upload/download)' },
+            remote_path: { type: 'string', description: 'Remote file path (for upload/download)' },
+            port: { type: 'number', description: 'SSH port (default: 22)' },
+        },
+        required: ['action', 'host'],
+    };
+    async execute(args) {
+        const action = args.action;
+        const host = args.host;
+        if (!action)
+            return 'Error: action is required';
+        if (!host)
+            return 'Error: host is required';
+        if (!SAFE_HOST.test(host))
+            return 'Error: host contains invalid characters (possible injection)';
+        const port = args.port || 22;
+        const portFlag = port !== 22 ? `-p ${port}` : '';
+        const scpPortFlag = port !== 22 ? `-P ${port}` : '';
+        switch (action) {
+            case 'exec': {
+                const cmd = args.command;
+                if (!cmd)
+                    return 'Error: command is required for exec';
+                return this.runSsh(`ssh ${portFlag} -o ConnectTimeout=10 -o StrictHostKeyChecking=accept-new ${host} ${JSON.stringify(cmd)}`);
+            }
+            case 'upload': {
+                const local = args.local_path;
+                const remote = args.remote_path;
+                if (!local || !remote)
+                    return 'Error: local_path and remote_path are required';
+                return this.runSsh(`scp ${scpPortFlag} -o ConnectTimeout=10 "${local}" ${host}:"${remote}"`);
+            }
+            case 'download': {
+                const local = args.local_path;
+                const remote = args.remote_path;
+                if (!local || !remote)
+                    return 'Error: local_path and remote_path are required';
+                return this.runSsh(`scp ${scpPortFlag} -o ConnectTimeout=10 ${host}:"${remote}" "${local}"`);
+            }
+            default:
+                return `Error: unknown action "${action}". Use: exec, upload, download`;
+        }
+    }
+    runSsh(cmd) {
+        try {
+            const output = (0, child_process_1.execSync)(cmd, {
+                timeout: 60_000,
+                maxBuffer: 2 * 1024 * 1024,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return output.trim() || '(no output)';
+        }
+        catch (err) {
+            const e = err;
+            const msg = (e.stderr || 'SSH command failed').trim();
+            if (msg.includes('Connection refused') || msg.includes('Connection timed out')) {
+                return `Error: could not connect to host. ${msg}`;
+            }
+            if (msg.includes('Permission denied')) {
+                return 'Error: authentication failed. Check SSH key or credentials.';
+            }
+            return `Exit ${e.status || 1}: ${msg}`;
+        }
+    }
+}
+exports.SshRemoteTool = SshRemoteTool;
+//# sourceMappingURL=ssh-remote.js.map

package/dist/tools/task-planner.d.ts

@@ -0,0 +1,42 @@
+import { Tool } from '../types';
+export declare class TaskPlannerTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            id: {
+                type: string;
+                description: string;
+            };
+            priority: {
+                type: string;
+                description: string;
+            };
+            status: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private addTask;
+    private listTasks;
+    private updateTask;
+    private completeTask;
+    private removeTask;
+    private clearDone;
+    private load;
+    private save;
+}
+//# sourceMappingURL=task-planner.d.ts.map

package/dist/tools/task-planner.js

@@ -0,0 +1,161 @@
+"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.TaskPlannerTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const TASKS_DIR = path.join(process.cwd(), '.codebot');
+const TASKS_FILE = path.join(TASKS_DIR, 'tasks.json');
+class TaskPlannerTool {
+    name = 'task_planner';
+    description = 'Plan and track tasks. Actions: add, list, update, complete, remove, clear.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: add, list, update, complete, remove, clear' },
+            title: { type: 'string', description: 'Task title (for add action)' },
+            id: { type: 'number', description: 'Task ID (for update/complete/remove)' },
+            priority: { type: 'string', description: 'Priority: high, medium, low (default: medium)' },
+            status: { type: 'string', description: 'New status for update action' },
+        },
+        required: ['action'],
+    };
+    async execute(args) {
+        const action = args.action;
+        if (!action)
+            return 'Error: action is required';
+        switch (action) {
+            case 'add': return this.addTask(args);
+            case 'list': return this.listTasks();
+            case 'update': return this.updateTask(args);
+            case 'complete': return this.completeTask(args);
+            case 'remove': return this.removeTask(args);
+            case 'clear': return this.clearDone();
+            default: return `Error: unknown action "${action}". Use: add, list, update, complete, remove, clear`;
+        }
+    }
+    addTask(args) {
+        const title = args.title;
+        if (!title)
+            return 'Error: title is required for add';
+        const tasks = this.load();
+        const id = tasks.length > 0 ? Math.max(...tasks.map(t => t.id)) + 1 : 1;
+        const priority = (['high', 'medium', 'low'].includes(args.priority) ? args.priority : 'medium');
+        tasks.push({ id, title, status: 'pending', priority, created: new Date().toISOString() });
+        this.save(tasks);
+        return `Added task #${id}: ${title} [${priority}]`;
+    }
+    listTasks() {
+        const tasks = this.load();
+        if (tasks.length === 0)
+            return 'No tasks.';
+        const icons = { pending: '○', in_progress: '◐', done: '●' };
+        const priIcons = { high: '!!!', medium: '!!', low: '!' };
+        const lines = tasks.map(t => `  ${icons[t.status] || '○'} #${t.id} [${priIcons[t.priority] || '!!'}] ${t.title} (${t.status})`);
+        const pending = tasks.filter(t => t.status === 'pending').length;
+        const inProgress = tasks.filter(t => t.status === 'in_progress').length;
+        const done = tasks.filter(t => t.status === 'done').length;
+        return `Tasks (${pending} pending, ${inProgress} active, ${done} done):\n${lines.join('\n')}`;
+    }
+    updateTask(args) {
+        const id = args.id;
+        if (!id)
+            return 'Error: id is required for update';
+        const tasks = this.load();
+        const task = tasks.find(t => t.id === id);
+        if (!task)
+            return `Error: task #${id} not found`;
+        if (args.status && ['pending', 'in_progress', 'done'].includes(args.status)) {
+            task.status = args.status;
+            if (task.status === 'done')
+                task.completed = new Date().toISOString();
+        }
+        if (args.title)
+            task.title = args.title;
+        if (args.priority && ['high', 'medium', 'low'].includes(args.priority)) {
+            task.priority = args.priority;
+        }
+        this.save(tasks);
+        return `Updated task #${id}: ${task.title} (${task.status})`;
+    }
+    completeTask(args) {
+        const id = args.id;
+        if (!id)
+            return 'Error: id is required for complete';
+        const tasks = this.load();
+        const task = tasks.find(t => t.id === id);
+        if (!task)
+            return `Error: task #${id} not found`;
+        task.status = 'done';
+        task.completed = new Date().toISOString();
+        this.save(tasks);
+        return `Completed task #${id}: ${task.title}`;
+    }
+    removeTask(args) {
+        const id = args.id;
+        if (!id)
+            return 'Error: id is required for remove';
+        const tasks = this.load();
+        const idx = tasks.findIndex(t => t.id === id);
+        if (idx === -1)
+            return `Error: task #${id} not found`;
+        const removed = tasks.splice(idx, 1)[0];
+        this.save(tasks);
+        return `Removed task #${id}: ${removed.title}`;
+    }
+    clearDone() {
+        const tasks = this.load();
+        const before = tasks.length;
+        const remaining = tasks.filter(t => t.status !== 'done');
+        this.save(remaining);
+        return `Cleared ${before - remaining.length} completed tasks. ${remaining.length} remaining.`;
+    }
+    load() {
+        try {
+            if (fs.existsSync(TASKS_FILE)) {
+                return JSON.parse(fs.readFileSync(TASKS_FILE, 'utf-8'));
+            }
+        }
+        catch { /* corrupt */ }
+        return [];
+    }
+    save(tasks) {
+        fs.mkdirSync(TASKS_DIR, { recursive: true });
+        fs.writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2) + '\n');
+    }
+}
+exports.TaskPlannerTool = TaskPlannerTool;
+//# sourceMappingURL=task-planner.js.map

package/dist/tools/test-runner.d.ts

@@ -0,0 +1,36 @@
+import { Tool } from '../types';
+export declare class TestRunnerTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            filter: {
+                type: string;
+                description: string;
+            };
+            cwd: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private detectFramework;
+    private listTestFiles;
+    private runTests;
+    private detect;
+    private summarize;
+    private findTests;
+}
+//# sourceMappingURL=test-runner.d.ts.map