@compilr-dev/agents-coding 0.0.1

package/dist/tools/runners/lint.js

@@ -0,0 +1,356 @@
+/**
+ * Run Lint Tool
+ * Auto-detect and run linter using the appropriate tool
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { isDirectory, readPackageJson, listDirectory, hasFile, hasDependency, hasScript, runCommand, buildCommand, formatCommand, DEFAULT_TIMEOUT, } from './utils.js';
+const LINTERS = [
+    // ESLint (Node.js)
+    {
+        name: 'eslint',
+        detect: (entries, pkg) => hasFile(entries, 'eslint.config.js') ||
+            hasFile(entries, 'eslint.config.mjs') ||
+            hasFile(entries, 'eslint.config.cjs') ||
+            hasFile(entries, '.eslintrc.js') ||
+            hasFile(entries, '.eslintrc.json') ||
+            hasFile(entries, '.eslintrc.yaml') ||
+            hasFile(entries, '.eslintrc.yml') ||
+            hasFile(entries, '.eslintrc') ||
+            hasDependency(pkg, 'eslint'),
+        getCommand: (input) => {
+            const args = ['eslint'];
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            if (input.fix)
+                args.push('--fix');
+            if (input.format)
+                args.push('--format', input.format);
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // Biome (Node.js)
+    {
+        name: 'biome',
+        detect: (entries, pkg) => hasFile(entries, 'biome.json') ||
+            hasFile(entries, 'biome.jsonc') ||
+            hasDependency(pkg, '@biomejs/biome'),
+        getCommand: (input) => {
+            const args = ['biome', 'lint'];
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            if (input.fix)
+                args.push('--apply');
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // npm lint script fallback (Node.js)
+    {
+        name: 'npm lint',
+        detect: (_entries, pkg) => hasScript(pkg, 'lint'),
+        getCommand: (input) => {
+            const args = ['run', 'lint'];
+            if (input.fix && hasScript(null, 'lint:fix')) {
+                return {
+                    command: 'npm',
+                    args: ['run', 'lint:fix'],
+                    useScript: true,
+                    scriptName: 'lint:fix',
+                };
+            }
+            return { command: 'npm', args, useScript: true, scriptName: 'lint' };
+        },
+    },
+    // Ruff (Python)
+    {
+        name: 'ruff',
+        detect: (entries) => hasFile(entries, 'ruff.toml') || hasFile(entries, '.ruff.toml'),
+        getCommand: (input) => {
+            const args = ['check'];
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            if (input.fix)
+                args.push('--fix');
+            if (input.format === 'json')
+                args.push('--output-format', 'json');
+            return { command: 'ruff', args };
+        },
+    },
+    // Pylint (Python)
+    {
+        name: 'pylint',
+        detect: (entries) => hasFile(entries, '.pylintrc') || hasFile(entries, 'pylintrc'),
+        getCommand: (input) => {
+            const args = [];
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            if (input.format === 'json')
+                args.push('--output-format=json');
+            return { command: 'pylint', args };
+        },
+    },
+    // Flake8 (Python)
+    {
+        name: 'flake8',
+        detect: (entries) => hasFile(entries, '.flake8') || hasFile(entries, 'setup.cfg'),
+        getCommand: (input) => {
+            const args = [];
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            if (input.format === 'json')
+                args.push('--format=json');
+            return { command: 'flake8', args };
+        },
+    },
+    // Clippy (Rust)
+    {
+        name: 'clippy',
+        detect: (entries) => hasFile(entries, 'Cargo.toml'),
+        getCommand: (input) => {
+            const args = ['clippy'];
+            if (input.fix)
+                args.push('--fix', '--allow-dirty');
+            args.push('--', '-D', 'warnings');
+            return { command: 'cargo', args };
+        },
+    },
+    // golangci-lint (Go)
+    {
+        name: 'golangci-lint',
+        detect: (entries) => hasFile(entries, '.golangci.yml') ||
+            hasFile(entries, '.golangci.yaml') ||
+            hasFile(entries, '.golangci.json') ||
+            hasFile(entries, 'go.mod'),
+        getCommand: (input) => {
+            const args = ['run'];
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            if (input.fix)
+                args.push('--fix');
+            if (input.format === 'json')
+                args.push('--out-format', 'json');
+            return { command: 'golangci-lint', args };
+        },
+    },
+];
+/**
+ * Run Lint Tool
+ */
+export const runLintTool = defineTool({
+    name: 'run_lint',
+    description: 'Run linter using the auto-detected linting tool. ' +
+        'Supports ESLint, Biome, Ruff, Pylint, Flake8, Clippy, golangci-lint, and npm lint scripts. ' +
+        'Options: files (specific files), fix (auto-fix), format (output format).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory (default: current directory)',
+            },
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Specific files to lint',
+            },
+            fix: {
+                type: 'boolean',
+                description: 'Auto-fix issues (if supported)',
+            },
+            format: {
+                type: 'string',
+                description: 'Output format (json, stylish, etc.)',
+            },
+            timeout: {
+                type: 'number',
+                description: 'Timeout in milliseconds (default: 300000)',
+            },
+            dryRun: {
+                type: 'boolean',
+                description: 'Detect linter and return command without executing (default: false)',
+            },
+        },
+        required: [],
+    },
+    execute: executeRunLint,
+});
+/**
+ * Execute run lint
+ */
+async function executeRunLint(input) {
+    const targetPath = input.path ?? process.cwd();
+    const timeout = input.timeout ?? DEFAULT_TIMEOUT;
+    // Check if directory exists
+    if (!(await isDirectory(targetPath))) {
+        return createErrorResult(`Directory not found: ${targetPath}`);
+    }
+    try {
+        // Read directory and package.json
+        const entries = await listDirectory(targetPath);
+        const packageJson = await readPackageJson(targetPath);
+        // Detect linter
+        let linter;
+        for (const l of LINTERS) {
+            if (l.detect(entries, packageJson)) {
+                linter = l;
+                break;
+            }
+        }
+        if (!linter) {
+            return createErrorResult('No linter detected. Supported: ESLint, Biome, Ruff, Pylint, Flake8, Clippy, golangci-lint, npm lint script.');
+        }
+        // Build command
+        const template = linter.getCommand(input);
+        const { command, args } = buildCommand(template);
+        const commandString = formatCommand(command, args);
+        // Dry run - return detected info without executing
+        if (input.dryRun) {
+            const lintResult = {
+                command: commandString,
+                output: '(dry run - command not executed)',
+                exitCode: 0,
+                duration: 0,
+                success: true,
+                linter: linter.name,
+            };
+            return createSuccessResult(lintResult);
+        }
+        // Run linter
+        const result = await runCommand(command, args, {
+            cwd: targetPath,
+            timeout,
+            env: {
+                FORCE_COLOR: '1',
+            },
+        });
+        // Combine output
+        const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
+        // Parse error/warning counts from output (best effort)
+        const counts = parseLintCounts(output, linter.name);
+        const lintResult = {
+            command: commandString,
+            output,
+            exitCode: result.exitCode,
+            duration: result.duration,
+            success: result.exitCode === 0,
+            linter: linter.name,
+            ...counts,
+        };
+        return createSuccessResult(lintResult);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Parse lint error/warning counts from output (best effort)
+ */
+function parseLintCounts(output, _linter) {
+    const counts = {};
+    // ESLint pattern: "✖ 5 problems (3 errors, 2 warnings)"
+    const eslintMatch = output.match(/(\d+)\s+errors?,\s+(\d+)\s+warnings?/i);
+    if (eslintMatch) {
+        counts.errors = parseInt(eslintMatch[1], 10);
+        counts.warnings = parseInt(eslintMatch[2], 10);
+    }
+    // Ruff pattern: "Found 10 errors."
+    const ruffMatch = output.match(/Found\s+(\d+)\s+errors?/i);
+    if (ruffMatch) {
+        counts.errors = parseInt(ruffMatch[1], 10);
+    }
+    // Pylint pattern: "Your code has been rated at 8.5/10"
+    // Pylint doesn't give direct counts easily, but we can try
+    const pylintErrorMatch = output.match(/E\d{4}:/g);
+    if (pylintErrorMatch) {
+        counts.errors = pylintErrorMatch.length;
+    }
+    const pylintWarnMatch = output.match(/W\d{4}:/g);
+    if (pylintWarnMatch) {
+        counts.warnings = pylintWarnMatch.length;
+    }
+    // Clippy pattern: "error:" and "warning:"
+    const clippyErrorMatch = output.match(/^error(\[E\d+\])?:/gm);
+    if (clippyErrorMatch) {
+        counts.errors = clippyErrorMatch.length;
+    }
+    const clippyWarnMatch = output.match(/^warning(\[.+\])?:/gm);
+    if (clippyWarnMatch) {
+        counts.warnings = clippyWarnMatch.length;
+    }
+    // golangci-lint pattern counts errors by lines with issues
+    const goLintMatch = output.match(/^[^:]+:\d+:\d+:/gm);
+    if (goLintMatch) {
+        counts.errors = goLintMatch.length;
+    }
+    return counts;
+}
+/**
+ * Factory function to create run lint tool with custom options
+ */
+export function createRunLintTool(options) {
+    return defineTool({
+        name: 'run_lint',
+        description: 'Run linter using the auto-detected linting tool. ' +
+            'Supports ESLint, Biome, Ruff, Pylint, Flake8, Clippy, golangci-lint.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory (default: current directory)',
+                },
+                files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific files to lint',
+                },
+                fix: {
+                    type: 'boolean',
+                    description: 'Auto-fix issues',
+                },
+                format: {
+                    type: 'string',
+                    description: 'Output format',
+                },
+                timeout: {
+                    type: 'number',
+                    description: 'Timeout in milliseconds',
+                },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            let targetPath = input.path ?? '.';
+            // Resolve relative paths
+            if (options?.baseDir && !targetPath.startsWith('/')) {
+                const nodePath = await import('node:path');
+                targetPath = nodePath.join(options.baseDir, targetPath);
+            }
+            return executeRunLint({
+                ...input,
+                path: targetPath,
+                timeout: input.timeout ?? options?.defaultTimeout,
+            });
+        },
+    });
+}

package/dist/tools/runners/test.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Run Tests Tool
+ * Auto-detect and run tests using the appropriate framework
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { RunTestsInput } from './types.js';
+/**
+ * Run Tests Tool
+ */
+export declare const runTestsTool: Tool<RunTestsInput>;
+/**
+ * Factory function to create run tests tool with custom options
+ */
+export declare function createRunTestsTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+    /** Default timeout */
+    defaultTimeout?: number;
+}): Tool<RunTestsInput>;