codebot-ai 1.3.0 → 1.4.1

package/dist/tools/code-review.js

@@ -0,0 +1,228 @@
+"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.CodeReviewTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SECURITY_PATTERNS = [
+    { pattern: /\beval\s*\(/, rule: 'no-eval', message: 'eval() is a security risk — allows arbitrary code execution', severity: 'error' },
+    { pattern: /new\s+Function\s*\(/, rule: 'no-new-function', message: 'new Function() is equivalent to eval()', severity: 'error' },
+    { pattern: /child_process.*exec(?!Sync)/, rule: 'unsafe-exec', message: 'exec() can be vulnerable to command injection — prefer execFile()', severity: 'warning' },
+    { pattern: /innerHTML\s*=/, rule: 'no-innerhtml', message: 'innerHTML is vulnerable to XSS attacks', severity: 'warning' },
+    { pattern: /document\.write\s*\(/, rule: 'no-document-write', message: 'document.write() is a security and performance issue', severity: 'warning' },
+    { pattern: /(?:password|secret|api.?key|token)\s*[:=]\s*['"][^'"]{8,}['"]/i, rule: 'hardcoded-secret', message: 'Possible hardcoded secret/credential', severity: 'error' },
+    { pattern: /\bsqlite3?\s.*\+\s*(?:req\.|args\.|input)/i, rule: 'sql-injection', message: 'Possible SQL injection — use parameterized queries', severity: 'error' },
+    { pattern: /https?:\/\/[^'"]*['"]\s*\+/, rule: 'url-injection', message: 'String concatenation in URL — possible injection', severity: 'warning' },
+    { pattern: /console\.(log|debug|info)\(/, rule: 'no-console', message: 'Console statement (consider removing for production)', severity: 'info' },
+    { pattern: /TODO|FIXME|HACK|XXX/i, rule: 'todo-comment', message: 'TODO/FIXME comment found', severity: 'info' },
+];
+class CodeReviewTool {
+    name = 'code_review';
+    description = 'Review code for security issues, complexity, and code smells. Actions: security, complexity, review (full).';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: security (scan for vulnerabilities), complexity (function/nesting analysis), review (full review)' },
+            path: { type: 'string', description: 'File or directory to review' },
+            severity: { type: 'string', description: 'Minimum severity to report: error, warning, info (default: warning)' },
+        },
+        required: ['action', 'path'],
+    };
+    async execute(args) {
+        const action = args.action;
+        const targetPath = args.path;
+        if (!action)
+            return 'Error: action is required';
+        if (!targetPath)
+            return 'Error: path is required';
+        if (!fs.existsSync(targetPath))
+            return `Error: path not found: ${targetPath}`;
+        const minSeverity = args.severity || 'warning';
+        switch (action) {
+            case 'security': return this.securityScan(targetPath, minSeverity);
+            case 'complexity': return this.complexityAnalysis(targetPath);
+            case 'review': {
+                const sec = this.securityScan(targetPath, minSeverity);
+                const comp = this.complexityAnalysis(targetPath);
+                return `=== Security Review ===\n${sec}\n\n=== Complexity Analysis ===\n${comp}`;
+            }
+            default: return `Error: unknown action "${action}". Use: security, complexity, review`;
+        }
+    }
+    securityScan(targetPath, minSeverity) {
+        const issues = [];
+        const sevOrder = { error: 3, warning: 2, info: 1 };
+        const minLevel = sevOrder[minSeverity] || 2;
+        const stat = fs.statSync(targetPath);
+        if (stat.isFile()) {
+            this.scanFile(targetPath, issues);
+        }
+        else {
+            this.scanDir(targetPath, issues);
+        }
+        // Filter by severity
+        const filtered = issues.filter(i => (sevOrder[i.severity] || 0) >= minLevel);
+        if (filtered.length === 0)
+            return 'No security issues found.';
+        const errors = filtered.filter(i => i.severity === 'error').length;
+        const warnings = filtered.filter(i => i.severity === 'warning').length;
+        const infos = filtered.filter(i => i.severity === 'info').length;
+        const icons = { error: 'X', warning: '!', info: 'i' };
+        const lines = filtered.slice(0, 50).map(i => `  [${icons[i.severity]}] ${i.file}:${i.line} ${i.rule} — ${i.message}`);
+        return `Found ${filtered.length} issue(s): ${errors} errors, ${warnings} warnings, ${infos} info\n${lines.join('\n')}`;
+    }
+    complexityAnalysis(targetPath) {
+        const stat = fs.statSync(targetPath);
+        const results = [];
+        if (stat.isFile()) {
+            this.analyzeFileComplexity(targetPath, results);
+        }
+        else {
+            this.analyzeDir(targetPath, results);
+        }
+        if (results.length === 0)
+            return 'No complexity issues found.';
+        return results.join('\n');
+    }
+    scanFile(filePath, issues) {
+        const ext = path.extname(filePath);
+        if (!['.ts', '.js', '.tsx', '.jsx', '.py', '.go', '.rb', '.java'].includes(ext))
+            return;
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                for (const check of SECURITY_PATTERNS) {
+                    if (check.pattern.test(lines[i])) {
+                        issues.push({
+                            file: filePath, line: i + 1,
+                            severity: check.severity, rule: check.rule, message: check.message,
+                        });
+                    }
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    scanDir(dir, issues) {
+        const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '__pycache__']);
+        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()) {
+                this.scanDir(full, issues);
+            }
+            else {
+                this.scanFile(full, issues);
+            }
+        }
+    }
+    analyzeFileComplexity(filePath, results) {
+        const ext = path.extname(filePath);
+        if (!['.ts', '.js', '.tsx', '.jsx', '.py', '.go'].includes(ext))
+            return;
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            let currentFunc = '';
+            let funcStart = 0;
+            let maxNesting = 0;
+            let currentNesting = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Detect function starts
+                const funcMatch = line.match(/(?:function|async function|def|fn|func)\s+(\w+)|(\w+)\s*[:=]\s*(?:async\s+)?\(/);
+                if (funcMatch) {
+                    // Report previous function if long
+                    if (currentFunc && (i - funcStart) > 50) {
+                        results.push(`  [!] ${filePath}:${funcStart + 1} "${currentFunc}" is ${i - funcStart} lines long (consider breaking up)`);
+                    }
+                    currentFunc = funcMatch[1] || funcMatch[2] || '';
+                    funcStart = i;
+                    maxNesting = 0;
+                }
+                // Track nesting
+                const opens = (line.match(/[{(]/g) || []).length;
+                const closes = (line.match(/[})]/g) || []).length;
+                currentNesting += opens - closes;
+                if (currentNesting > maxNesting)
+                    maxNesting = currentNesting;
+                if (maxNesting > 5 && currentFunc) {
+                    results.push(`  [!] ${filePath}:${i + 1} deep nesting (${maxNesting} levels) in "${currentFunc}"`);
+                    maxNesting = 0; // Don't re-report
+                }
+            }
+            // Check last function
+            if (currentFunc && (lines.length - funcStart) > 50) {
+                results.push(`  [!] ${filePath}:${funcStart + 1} "${currentFunc}" is ${lines.length - funcStart} lines long`);
+            }
+            // File-level checks
+            if (lines.length > 500) {
+                results.push(`  [i] ${filePath}: ${lines.length} lines — consider splitting into modules`);
+            }
+        }
+        catch { /* skip */ }
+    }
+    analyzeDir(dir, results) {
+        const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage']);
+        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())
+                this.analyzeDir(full, results);
+            else
+                this.analyzeFileComplexity(full, results);
+        }
+    }
+}
+exports.CodeReviewTool = CodeReviewTool;
+//# sourceMappingURL=code-review.js.map

package/dist/tools/database.d.ts

@@ -0,0 +1,35 @@
+import { Tool } from '../types';
+export declare class DatabaseTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            db: {
+                type: string;
+                description: string;
+            };
+            sql: {
+                type: string;
+                description: string;
+            };
+            table: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private runQuery;
+    private listTables;
+    private showSchema;
+    private dbInfo;
+    private sqlite;
+}
+//# sourceMappingURL=database.d.ts.map

package/dist/tools/database.js

@@ -0,0 +1,129 @@
+"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.DatabaseTool = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const BLOCKED_SQL = [
+    /\bDROP\s+(TABLE|DATABASE|INDEX|VIEW)\b/i,
+    /\bDELETE\s+FROM\b/i,
+    /\bTRUNCATE\b/i,
+    /\bALTER\s+TABLE\s+.*\bDROP\b/i,
+];
+class DatabaseTool {
+    name = 'database';
+    description = 'Query SQLite databases. Actions: query, tables, schema, info. Blocks DROP/DELETE/TRUNCATE for safety.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: query, tables, schema, info' },
+            db: { type: 'string', description: 'Path to SQLite database file' },
+            sql: { type: 'string', description: 'SQL query to execute (for "query" action)' },
+            table: { type: 'string', description: 'Table name (for "schema" action)' },
+        },
+        required: ['action', 'db'],
+    };
+    async execute(args) {
+        const action = args.action;
+        const dbPath = args.db;
+        if (!action)
+            return 'Error: action is required';
+        if (!dbPath)
+            return 'Error: db path is required';
+        if (!fs.existsSync(dbPath))
+            return `Error: database not found: ${dbPath}`;
+        switch (action) {
+            case 'query': return this.runQuery(dbPath, args);
+            case 'tables': return this.listTables(dbPath);
+            case 'schema': return this.showSchema(dbPath, args);
+            case 'info': return this.dbInfo(dbPath);
+            default: return `Error: unknown action "${action}". Use: query, tables, schema, info`;
+        }
+    }
+    runQuery(dbPath, args) {
+        const sql = args.sql;
+        if (!sql)
+            return 'Error: sql is required for query';
+        // Block destructive queries
+        for (const pattern of BLOCKED_SQL) {
+            if (pattern.test(sql)) {
+                return `Error: destructive SQL blocked for safety. Pattern matched: ${pattern.source}`;
+            }
+        }
+        return this.sqlite(dbPath, sql);
+    }
+    listTables(dbPath) {
+        return this.sqlite(dbPath, ".tables");
+    }
+    showSchema(dbPath, args) {
+        const table = args.table;
+        if (table) {
+            // Sanitize table name
+            if (!/^[a-zA-Z_]\w*$/.test(table))
+                return 'Error: invalid table name';
+            return this.sqlite(dbPath, `.schema ${table}`);
+        }
+        return this.sqlite(dbPath, ".schema");
+    }
+    dbInfo(dbPath) {
+        const stat = fs.statSync(dbPath);
+        const sizeMB = (stat.size / (1024 * 1024)).toFixed(2);
+        const tables = this.sqlite(dbPath, "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;");
+        return `Database: ${dbPath}\nSize: ${sizeMB} MB\nModified: ${stat.mtime.toISOString()}\n\nTables:\n${tables}`;
+    }
+    sqlite(dbPath, command) {
+        try {
+            // Try sqlite3 CLI first
+            const output = (0, child_process_1.execSync)(`sqlite3 "${dbPath}" "${command.replace(/"/g, '\\"')}"`, {
+                timeout: 15_000,
+                maxBuffer: 1024 * 1024,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return output.trim() || '(no results)';
+        }
+        catch (err) {
+            const e = err;
+            const msg = (e.stderr || '').trim();
+            if (msg.includes('not found')) {
+                return 'Error: sqlite3 is not installed. Install it with: brew install sqlite (macOS) or apt install sqlite3 (Linux)';
+            }
+            return `Error: ${msg || 'query failed'}`;
+        }
+    }
+}
+exports.DatabaseTool = DatabaseTool;
+//# sourceMappingURL=database.js.map

package/dist/tools/diff-viewer.d.ts

@@ -0,0 +1,39 @@
+import { Tool } from '../types';
+export declare class DiffViewerTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            file_a: {
+                type: string;
+                description: string;
+            };
+            file_b: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            ref: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private diffFiles;
+    private gitDiff;
+    private gitStaged;
+    private gitCommitDiff;
+    private runGit;
+}
+//# sourceMappingURL=diff-viewer.d.ts.map

package/dist/tools/diff-viewer.js

@@ -0,0 +1,145 @@
+"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.DiffViewerTool = void 0;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+class DiffViewerTool {
+    name = 'diff_viewer';
+    description = 'View diffs. Actions: files (compare two files), git_diff (working tree changes), staged (staged changes), commit (show a commit diff).';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: files, git_diff, staged, commit' },
+            file_a: { type: 'string', description: 'First file path (for "files" action)' },
+            file_b: { type: 'string', description: 'Second file path (for "files" action)' },
+            path: { type: 'string', description: 'File or directory to diff (for git_diff/staged)' },
+            ref: { type: 'string', description: 'Commit hash or ref (for "commit" action)' },
+        },
+        required: ['action'],
+    };
+    async execute(args) {
+        const action = args.action;
+        if (!action)
+            return 'Error: action is required';
+        switch (action) {
+            case 'files': return this.diffFiles(args);
+            case 'git_diff': return this.gitDiff(args);
+            case 'staged': return this.gitStaged(args);
+            case 'commit': return this.gitCommitDiff(args);
+            default: return `Error: unknown action "${action}". Use: files, git_diff, staged, commit`;
+        }
+    }
+    diffFiles(args) {
+        const fileA = args.file_a;
+        const fileB = args.file_b;
+        if (!fileA || !fileB)
+            return 'Error: file_a and file_b are required';
+        let contentA, contentB;
+        try {
+            contentA = fs.readFileSync(fileA, 'utf-8');
+        }
+        catch {
+            return `Error: cannot read ${fileA}`;
+        }
+        try {
+            contentB = fs.readFileSync(fileB, 'utf-8');
+        }
+        catch {
+            return `Error: cannot read ${fileB}`;
+        }
+        const linesA = contentA.split('\n');
+        const linesB = contentB.split('\n');
+        const diff = [`--- ${fileA}`, `+++ ${fileB}`];
+        // Simple line-by-line diff
+        const maxLen = Math.max(linesA.length, linesB.length);
+        let changes = 0;
+        for (let i = 0; i < maxLen; i++) {
+            const a = linesA[i];
+            const b = linesB[i];
+            if (a === undefined && b !== undefined) {
+                diff.push(`+${i + 1}: ${b}`);
+                changes++;
+            }
+            else if (b === undefined && a !== undefined) {
+                diff.push(`-${i + 1}: ${a}`);
+                changes++;
+            }
+            else if (a !== b) {
+                diff.push(`-${i + 1}: ${a}`);
+                diff.push(`+${i + 1}: ${b}`);
+                changes++;
+            }
+        }
+        if (changes === 0)
+            return 'Files are identical.';
+        return `${changes} line(s) differ:\n${diff.join('\n')}`;
+    }
+    gitDiff(args) {
+        const target = args.path || '';
+        return this.runGit(`diff ${target}`.trim());
+    }
+    gitStaged(args) {
+        const target = args.path || '';
+        return this.runGit(`diff --staged ${target}`.trim());
+    }
+    gitCommitDiff(args) {
+        const ref = args.ref;
+        if (!ref)
+            return 'Error: ref (commit hash) is required';
+        // Sanitize ref
+        if (!/^[a-zA-Z0-9_\-./~^]+$/.test(ref))
+            return 'Error: invalid ref format';
+        return this.runGit(`show --stat --patch ${ref}`);
+    }
+    runGit(cmd) {
+        try {
+            const output = (0, child_process_1.execSync)(`git ${cmd}`, {
+                timeout: 15_000,
+                maxBuffer: 1024 * 1024,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return output.trim() || 'No changes.';
+        }
+        catch (err) {
+            const e = err;
+            return `Error: ${(e.stderr || 'git command failed').trim()}`;
+        }
+    }
+}
+exports.DiffViewerTool = DiffViewerTool;
+//# sourceMappingURL=diff-viewer.js.map

package/dist/tools/docker.d.ts

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