codebot-ai 1.2.3 → 1.4.0

package/dist/tools/package-manager.d.ts

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

package/dist/tools/package-manager.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.PackageManagerTool = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const MANAGERS = {
+    npm: {
+        name: 'npm', install: 'npm install', add: 'npm install',
+        remove: 'npm uninstall', list: 'npm ls --depth=0', outdated: 'npm outdated', audit: 'npm audit',
+    },
+    yarn: {
+        name: 'yarn', install: 'yarn install', add: 'yarn add',
+        remove: 'yarn remove', list: 'yarn list --depth=0', outdated: 'yarn outdated', audit: 'yarn audit',
+    },
+    pnpm: {
+        name: 'pnpm', install: 'pnpm install', add: 'pnpm add',
+        remove: 'pnpm remove', list: 'pnpm ls --depth=0', outdated: 'pnpm outdated', audit: 'pnpm audit',
+    },
+    pip: {
+        name: 'pip', install: 'pip install -r requirements.txt', add: 'pip install',
+        remove: 'pip uninstall -y', list: 'pip list', outdated: 'pip list --outdated', audit: 'pip audit',
+    },
+    cargo: {
+        name: 'cargo', install: 'cargo build', add: 'cargo add',
+        remove: 'cargo remove', list: 'cargo tree --depth=1', outdated: 'cargo outdated', audit: 'cargo audit',
+    },
+    go: {
+        name: 'go', install: 'go mod download', add: 'go get',
+        remove: 'go mod tidy', list: 'go list -m all', outdated: 'go list -m -u all', audit: 'govulncheck ./...',
+    },
+};
+class PackageManagerTool {
+    name = 'package_manager';
+    description = 'Manage dependencies. Auto-detects npm/yarn/pnpm/pip/cargo/go. Actions: install, add, remove, list, outdated, audit, detect.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: install, add, remove, list, outdated, audit, detect' },
+            package: { type: 'string', description: 'Package name (for add/remove)' },
+            cwd: { type: 'string', description: 'Working directory' },
+            manager: { type: 'string', description: 'Force specific manager (npm, yarn, pnpm, pip, cargo, go)' },
+        },
+        required: ['action'],
+    };
+    async execute(args) {
+        const action = args.action;
+        if (!action)
+            return 'Error: action is required';
+        const cwd = args.cwd || process.cwd();
+        if (action === 'detect') {
+            const mgr = this.detect(cwd, args.manager);
+            return mgr ? `Detected: ${mgr.name}` : 'No package manager detected.';
+        }
+        const mgr = this.detect(cwd, args.manager);
+        if (!mgr)
+            return 'Error: no package manager detected. Specify with manager parameter.';
+        let cmd;
+        switch (action) {
+            case 'install':
+                cmd = mgr.install;
+                break;
+            case 'add': {
+                const pkg = args.package;
+                if (!pkg)
+                    return 'Error: package name is required for add';
+                cmd = `${mgr.add} ${pkg}`;
+                break;
+            }
+            case 'remove': {
+                const pkg = args.package;
+                if (!pkg)
+                    return 'Error: package name is required for remove';
+                cmd = `${mgr.remove} ${pkg}`;
+                break;
+            }
+            case 'list':
+                cmd = mgr.list;
+                break;
+            case 'outdated':
+                cmd = mgr.outdated;
+                break;
+            case 'audit':
+                cmd = mgr.audit;
+                break;
+            default: return `Error: unknown action "${action}". Use: install, add, remove, list, outdated, audit, detect`;
+        }
+        try {
+            const output = (0, child_process_1.execSync)(cmd, {
+                cwd,
+                timeout: 120_000,
+                maxBuffer: 2 * 1024 * 1024,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return output.trim() || '(no output)';
+        }
+        catch (err) {
+            const e = err;
+            // Audit and outdated commands often exit non-zero when issues are found
+            if (['audit', 'outdated'].includes(action) && e.stdout) {
+                return e.stdout.trim();
+            }
+            return `Exit ${e.status || 1}:\n${(e.stdout || '').trim()}\n${(e.stderr || '').trim()}`.trim();
+        }
+    }
+    detect(cwd, forced) {
+        if (forced && MANAGERS[forced])
+            return MANAGERS[forced];
+        // Check lock files
+        if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))
+            return MANAGERS.pnpm;
+        if (fs.existsSync(path.join(cwd, 'yarn.lock')))
+            return MANAGERS.yarn;
+        if (fs.existsSync(path.join(cwd, 'package-lock.json')) || fs.existsSync(path.join(cwd, 'package.json')))
+            return MANAGERS.npm;
+        if (fs.existsSync(path.join(cwd, 'requirements.txt')) || fs.existsSync(path.join(cwd, 'setup.py')) || fs.existsSync(path.join(cwd, 'pyproject.toml')))
+            return MANAGERS.pip;
+        if (fs.existsSync(path.join(cwd, 'Cargo.toml')))
+            return MANAGERS.cargo;
+        if (fs.existsSync(path.join(cwd, 'go.mod')))
+            return MANAGERS.go;
+        return null;
+    }
+}
+exports.PackageManagerTool = PackageManagerTool;
+//# sourceMappingURL=package-manager.js.map

package/dist/tools/pdf-extract.d.ts

@@ -0,0 +1,33 @@
+import { Tool } from '../types';
+export declare class PdfExtractTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            max_pages: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private extractText;
+    private getInfo;
+    private countPages;
+    private estimatePageCount;
+    private extractFromBuffer;
+    private decodePdfString;
+    private extractMeta;
+}
+//# sourceMappingURL=pdf-extract.d.ts.map

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