codebot-ai 1.3.0 → 1.4.1

package/dist/tools/multi-search.js

@@ -0,0 +1,153 @@
+"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.MultiSearchTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class MultiSearchTool {
+    name = 'multi_search';
+    description = 'Fuzzy search across filenames, file contents, and code symbols. Returns ranked results by relevance.';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query (fuzzy matched against filenames, content, and symbols)' },
+            path: { type: 'string', description: 'Directory to search (defaults to current)' },
+            max_results: { type: 'number', description: 'Max results to return (default: 20)' },
+        },
+        required: ['query'],
+    };
+    async execute(args) {
+        const query = args.query;
+        if (!query)
+            return 'Error: query is required';
+        const searchPath = args.path || process.cwd();
+        const maxResults = args.max_results || 20;
+        if (!fs.existsSync(searchPath))
+            return `Error: path not found: ${searchPath}`;
+        const results = [];
+        const queryLower = query.toLowerCase();
+        const queryParts = queryLower.split(/\s+/);
+        this.searchDir(searchPath, queryLower, queryParts, results);
+        // Sort by score descending
+        results.sort((a, b) => b.score - a.score);
+        const top = results.slice(0, maxResults);
+        if (top.length === 0)
+            return `No results for "${query}".`;
+        const lines = top.map(r => {
+            const tag = r.type === 'filename' ? '[file]' : r.type === 'symbol' ? '[symbol]' : '[content]';
+            const loc = r.line ? `:${r.line}` : '';
+            const preview = r.text ? ` — ${r.text.substring(0, 80)}` : '';
+            return `  ${tag} ${r.file}${loc}${preview}`;
+        });
+        return `Search results for "${query}" (${top.length} matches):\n${lines.join('\n')}`;
+    }
+    searchDir(dir, query, parts, results) {
+        const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '__pycache__', '.next']);
+        const codeExts = new Set(['.ts', '.js', '.tsx', '.jsx', '.py', '.go', '.rs', '.java', '.rb', '.c', '.cpp', '.h', '.css', '.html', '.json', '.md', '.yaml', '.yml', '.toml']);
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || skip.has(entry.name))
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Score directory name
+                const dirScore = this.fuzzyScore(entry.name.toLowerCase(), query, parts);
+                if (dirScore > 0) {
+                    results.push({ file: full + '/', score: dirScore * 0.5, type: 'filename' });
+                }
+                this.searchDir(full, query, parts, results);
+            }
+            else {
+                // Filename match
+                const nameScore = this.fuzzyScore(entry.name.toLowerCase(), query, parts);
+                if (nameScore > 0) {
+                    results.push({ file: full, score: nameScore, type: 'filename' });
+                }
+                // Content + symbol search for code files
+                const ext = path.extname(entry.name).toLowerCase();
+                if (!codeExts.has(ext))
+                    continue;
+                try {
+                    const content = fs.readFileSync(full, 'utf-8');
+                    if (content.length > 500_000 || content.includes('\0'))
+                        continue; // skip huge/binary
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        const lineLower = line.toLowerCase();
+                        // Content match
+                        if (lineLower.includes(query)) {
+                            results.push({ file: full, line: i + 1, text: line.trimEnd(), score: 3, type: 'content' });
+                        }
+                        // Symbol match (class, function, method definitions)
+                        const symbolMatch = line.match(/(?:class|function|interface|type|const|let|var|def|fn|func)\s+(\w+)/);
+                        if (symbolMatch) {
+                            const symScore = this.fuzzyScore(symbolMatch[1].toLowerCase(), query, parts);
+                            if (symScore > 0) {
+                                results.push({ file: full, line: i + 1, text: line.trimEnd(), score: symScore * 1.5, type: 'symbol' });
+                            }
+                        }
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    fuzzyScore(target, query, parts) {
+        // Exact match
+        if (target === query)
+            return 10;
+        // Contains full query
+        if (target.includes(query))
+            return 7;
+        // All parts present
+        if (parts.every(p => target.includes(p)))
+            return 5;
+        // Some parts present
+        const matched = parts.filter(p => target.includes(p)).length;
+        if (matched > 0)
+            return matched * 2;
+        return 0;
+    }
+}
+exports.MultiSearchTool = MultiSearchTool;
+//# sourceMappingURL=multi-search.js.map

package/dist/tools/notification.d.ts

@@ -0,0 +1,38 @@
+import { Tool } from '../types';
+export declare class NotificationTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            url: {
+                type: string;
+                description: string;
+            };
+            message: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            severity: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private sendSlack;
+    private sendDiscord;
+    private sendGeneric;
+    private post;
+}
+//# sourceMappingURL=notification.d.ts.map

package/dist/tools/notification.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationTool = void 0;
+class NotificationTool {
+    name = 'notification';
+    description = 'Send notifications via webhook (Slack, Discord, or generic). Actions: slack, discord, webhook.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: slack, discord, webhook' },
+            url: { type: 'string', description: 'Webhook URL' },
+            message: { type: 'string', description: 'Message text' },
+            title: { type: 'string', description: 'Optional title/subject' },
+            severity: { type: 'string', description: 'Severity: info, warning, error, success (affects color)' },
+        },
+        required: ['action', 'url', 'message'],
+    };
+    async execute(args) {
+        const action = args.action;
+        const url = args.url;
+        const message = args.message;
+        if (!action)
+            return 'Error: action is required';
+        if (!url)
+            return 'Error: url is required';
+        if (!message)
+            return 'Error: message is required';
+        // Validate URL
+        try {
+            new URL(url);
+        }
+        catch {
+            return `Error: invalid URL: ${url}`;
+        }
+        const title = args.title || '';
+        const severity = args.severity || 'info';
+        switch (action) {
+            case 'slack': return this.sendSlack(url, message, title, severity);
+            case 'discord': return this.sendDiscord(url, message, title, severity);
+            case 'webhook': return this.sendGeneric(url, message, title, severity);
+            default: return `Error: unknown action "${action}". Use: slack, discord, webhook`;
+        }
+    }
+    async sendSlack(url, message, title, severity) {
+        const colors = { info: '#2196F3', warning: '#FF9800', error: '#F44336', success: '#4CAF50' };
+        const payload = {
+            attachments: [{
+                    color: colors[severity] || colors.info,
+                    title: title || undefined,
+                    text: message,
+                    ts: Math.floor(Date.now() / 1000),
+                }],
+        };
+        return this.post(url, payload);
+    }
+    async sendDiscord(url, message, title, severity) {
+        const colors = { info: 0x2196F3, warning: 0xFF9800, error: 0xF44336, success: 0x4CAF50 };
+        const payload = {
+            embeds: [{
+                    title: title || undefined,
+                    description: message,
+                    color: colors[severity] || colors.info,
+                    timestamp: new Date().toISOString(),
+                }],
+        };
+        return this.post(url, payload);
+    }
+    async sendGeneric(url, message, title, severity) {
+        const payload = { title, message, severity, timestamp: new Date().toISOString() };
+        return this.post(url, payload);
+    }
+    async post(url, payload) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 15_000);
+        try {
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            if (res.ok)
+                return `Notification sent (${res.status}).`;
+            const body = await res.text().catch(() => '');
+            return `Error: webhook returned ${res.status} ${res.statusText}${body ? `: ${body.substring(0, 200)}` : ''}`;
+        }
+        catch (err) {
+            clearTimeout(timer);
+            return `Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+}
+exports.NotificationTool = NotificationTool;
+//# sourceMappingURL=notification.js.map

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