codebot-ai 1.3.0 → 1.4.1

package/dist/tools/test-runner.js

@@ -0,0 +1,193 @@
+"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.TestRunnerTool = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class TestRunnerTool {
+    name = 'test_runner';
+    description = 'Run tests with auto-detected framework. Actions: run (execute tests), detect (show detected framework), list (list test files).';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: run, detect, list' },
+            path: { type: 'string', description: 'Test file or directory (defaults to project root)' },
+            filter: { type: 'string', description: 'Test name filter / grep pattern' },
+            cwd: { type: 'string', description: 'Working directory' },
+        },
+        required: ['action'],
+    };
+    async execute(args) {
+        const action = args.action;
+        if (!action)
+            return 'Error: action is required';
+        const cwd = args.cwd || process.cwd();
+        switch (action) {
+            case 'detect': return this.detectFramework(cwd);
+            case 'list': return this.listTestFiles(cwd);
+            case 'run': return this.runTests(cwd, args);
+            default: return `Error: unknown action "${action}". Use: run, detect, list`;
+        }
+    }
+    detectFramework(cwd) {
+        const fw = this.detect(cwd);
+        if (!fw)
+            return 'No test framework detected. Checked for: jest, vitest, mocha, node:test, pytest, go test, cargo test.';
+        return `Detected: ${fw.name}\nCommand: ${fw.command}\nTest files: ${fw.filePattern}`;
+    }
+    listTestFiles(cwd) {
+        const patterns = ['**/*.test.*', '**/*.spec.*', '**/test_*.py', '**/*_test.go', '**/tests/**'];
+        const files = [];
+        const skip = new Set(['node_modules', '.git', 'dist', 'build', 'coverage']);
+        this.findTests(cwd, files, skip, 0, 4);
+        if (files.length === 0)
+            return 'No test files found.';
+        return `Test files (${files.length}):\n${files.map(f => `  ${f}`).join('\n')}`;
+    }
+    runTests(cwd, args) {
+        const fw = this.detect(cwd);
+        if (!fw)
+            return 'Error: no test framework detected';
+        let cmd = fw.command;
+        const target = args.path;
+        const filter = args.filter;
+        if (target)
+            cmd += ` ${target}`;
+        if (filter) {
+            if (fw.name.includes('jest') || fw.name.includes('vitest'))
+                cmd += ` -t "${filter}"`;
+            else if (fw.name === 'pytest')
+                cmd += ` -k "${filter}"`;
+            else if (fw.name === 'go test')
+                cmd += ` -run "${filter}"`;
+        }
+        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 this.summarize(output, fw.name);
+        }
+        catch (err) {
+            const e = err;
+            const combined = `${e.stdout || ''}\n${e.stderr || ''}`.trim();
+            return `Tests failed (exit ${e.status || 1}):\n${this.summarize(combined, fw.name)}`;
+        }
+    }
+    detect(cwd) {
+        // Check package.json for JS/TS projects
+        const pkgPath = path.join(cwd, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                const scripts = pkg.scripts || {};
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (scripts.test) {
+                    if (scripts.test.includes('vitest'))
+                        return { name: 'vitest', command: 'npx vitest run', filePattern: '*.test.ts' };
+                    if (scripts.test.includes('jest'))
+                        return { name: 'jest', command: 'npx jest', filePattern: '*.test.ts' };
+                    if (scripts.test.includes('mocha'))
+                        return { name: 'mocha', command: 'npx mocha', filePattern: '*.test.ts' };
+                    if (scripts.test.includes('node --test'))
+                        return { name: 'node:test', command: scripts.test, filePattern: '*.test.ts' };
+                    // Generic npm test
+                    return { name: 'npm test', command: 'npm test', filePattern: '*.test.*' };
+                }
+                if (deps['vitest'])
+                    return { name: 'vitest', command: 'npx vitest run', filePattern: '*.test.ts' };
+                if (deps['jest'])
+                    return { name: 'jest', command: 'npx jest', filePattern: '*.test.ts' };
+            }
+            catch { /* invalid package.json */ }
+        }
+        // Python
+        if (fs.existsSync(path.join(cwd, 'pytest.ini')) || fs.existsSync(path.join(cwd, 'setup.py')) || fs.existsSync(path.join(cwd, 'pyproject.toml'))) {
+            return { name: 'pytest', command: 'python -m pytest -v', filePattern: 'test_*.py' };
+        }
+        // Go
+        if (fs.existsSync(path.join(cwd, 'go.mod'))) {
+            return { name: 'go test', command: 'go test ./...', filePattern: '*_test.go' };
+        }
+        // Rust
+        if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) {
+            return { name: 'cargo test', command: 'cargo test', filePattern: '*.rs' };
+        }
+        return null;
+    }
+    summarize(output, framework) {
+        const lines = output.split('\n');
+        const summary = [];
+        // Extract pass/fail counts
+        for (const line of lines) {
+            if (/(?:pass|fail|error|skip|pending|test|ok|FAIL)/i.test(line) && line.trim().length < 200) {
+                summary.push(line);
+            }
+        }
+        if (summary.length > 30) {
+            return summary.slice(-30).join('\n') + '\n...(truncated)';
+        }
+        return summary.length > 0 ? summary.join('\n') : output.substring(0, 2000);
+    }
+    findTests(dir, files, skip, depth, maxDepth) {
+        if (depth >= maxDepth)
+            return;
+        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.findTests(full, files, skip, depth + 1, maxDepth);
+            }
+            else if (/\.(test|spec)\.\w+$/.test(entry.name) || /^test_.*\.py$/.test(entry.name) || /_test\.go$/.test(entry.name)) {
+                files.push(full);
+            }
+        }
+    }
+}
+exports.TestRunnerTool = TestRunnerTool;
+//# sourceMappingURL=test-runner.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebot-ai",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Zero-dependency autonomous AI agent. Code, browse, search, automate. Works with any LLM — Ollama, Claude, GPT, Gemini, DeepSeek, Groq, Mistral, Grok.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",