@compilr-dev/agents-coding 0.0.1

package/dist/tools/runners/test.js

@@ -0,0 +1,386 @@
+/**
+ * Run Tests Tool
+ * Auto-detect and run tests using the appropriate framework
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { isDirectory, readPackageJson, listDirectory, hasFile, hasDependency, hasScript, runCommand, buildCommand, formatCommand, DEFAULT_TIMEOUT, } from './utils.js';
+const TEST_FRAMEWORKS = [
+    // Vitest (Node.js)
+    {
+        name: 'vitest',
+        detect: (entries, pkg) => hasFile(entries, 'vitest.config.ts') ||
+            hasFile(entries, 'vitest.config.js') ||
+            hasFile(entries, 'vitest.config.mts') ||
+            hasDependency(pkg, 'vitest'),
+        getCommand: (input) => {
+            const args = ['vitest'];
+            if (!input.watch)
+                args.push('run');
+            if (input.pattern)
+                args.push(input.pattern);
+            if (input.coverage)
+                args.push('--coverage');
+            if (input.updateSnapshots)
+                args.push('-u');
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // Jest (Node.js)
+    {
+        name: 'jest',
+        detect: (entries, pkg) => hasFile(entries, 'jest.config.ts') ||
+            hasFile(entries, 'jest.config.js') ||
+            hasFile(entries, 'jest.config.json') ||
+            hasDependency(pkg, 'jest'),
+        getCommand: (input) => {
+            const args = ['jest'];
+            if (input.pattern)
+                args.push(input.pattern);
+            if (!input.watch)
+                args.push('--runInBand');
+            if (input.watch)
+                args.push('--watch');
+            if (input.coverage)
+                args.push('--coverage');
+            if (input.updateSnapshots)
+                args.push('-u');
+            if (input.verbose)
+                args.push('--verbose');
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // Mocha (Node.js)
+    {
+        name: 'mocha',
+        detect: (entries, pkg) => hasFile(entries, '.mocharc.json') ||
+            hasFile(entries, '.mocharc.js') ||
+            hasFile(entries, '.mocharc.yaml') ||
+            hasDependency(pkg, 'mocha'),
+        getCommand: (input) => {
+            const args = ['mocha'];
+            if (input.pattern)
+                args.push(input.pattern);
+            if (input.watch)
+                args.push('--watch');
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // AVA (Node.js)
+    {
+        name: 'ava',
+        detect: (entries, pkg) => hasFile(entries, 'ava.config.js') ||
+            hasFile(entries, 'ava.config.cjs') ||
+            hasDependency(pkg, 'ava'),
+        getCommand: (input) => {
+            const args = ['ava'];
+            if (input.pattern)
+                args.push(input.pattern);
+            if (input.watch)
+                args.push('--watch');
+            if (input.verbose)
+                args.push('--verbose');
+            if (input.updateSnapshots)
+                args.push('-u');
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // npm test script fallback (Node.js)
+    {
+        name: 'npm test',
+        detect: (_entries, pkg) => hasScript(pkg, 'test'),
+        getCommand: () => ({
+            command: 'npm',
+            args: ['test'],
+            useScript: true,
+            scriptName: 'test',
+        }),
+    },
+    // pytest (Python)
+    {
+        name: 'pytest',
+        detect: (entries) => hasFile(entries, 'pytest.ini') ||
+            hasFile(entries, 'pyproject.toml') ||
+            hasFile(entries, 'conftest.py'),
+        getCommand: (input) => {
+            const args = [];
+            if (input.pattern)
+                args.push(input.pattern);
+            if (input.verbose)
+                args.push('-v');
+            if (input.coverage)
+                args.push('--cov');
+            return { command: 'pytest', args };
+        },
+    },
+    // Python unittest
+    {
+        name: 'unittest',
+        detect: (entries) => hasFile(entries, 'setup.py') || hasFile(entries, 'setup.cfg'),
+        getCommand: (input) => {
+            const args = ['-m', 'unittest'];
+            if (input.pattern)
+                args.push('discover', '-p', input.pattern);
+            else
+                args.push('discover');
+            if (input.verbose)
+                args.push('-v');
+            return { command: 'python', args };
+        },
+    },
+    // Cargo test (Rust)
+    {
+        name: 'cargo test',
+        detect: (entries) => hasFile(entries, 'Cargo.toml'),
+        getCommand: (input) => {
+            const args = ['test'];
+            if (input.pattern)
+                args.push(input.pattern);
+            if (input.verbose)
+                args.push('--', '--nocapture');
+            return { command: 'cargo', args };
+        },
+    },
+    // Go test
+    {
+        name: 'go test',
+        detect: (entries) => hasFile(entries, 'go.mod'),
+        getCommand: (input) => {
+            const args = ['test'];
+            if (input.pattern)
+                args.push(input.pattern);
+            else
+                args.push('./...');
+            if (input.verbose)
+                args.push('-v');
+            if (input.coverage)
+                args.push('-cover');
+            return { command: 'go', args };
+        },
+    },
+];
+/**
+ * Run Tests Tool
+ */
+export const runTestsTool = defineTool({
+    name: 'run_tests',
+    description: 'Run tests using the auto-detected test framework. ' +
+        'Supports vitest, jest, mocha, pytest, cargo test, go test, and npm test scripts. ' +
+        'Options: pattern (filter tests), watch, coverage, verbose, updateSnapshots.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory (default: current directory)',
+            },
+            pattern: {
+                type: 'string',
+                description: 'Test file pattern or test name filter',
+            },
+            watch: {
+                type: 'boolean',
+                description: 'Run in watch mode (if supported)',
+            },
+            verbose: {
+                type: 'boolean',
+                description: 'Verbose output',
+            },
+            coverage: {
+                type: 'boolean',
+                description: 'Generate coverage report',
+            },
+            updateSnapshots: {
+                type: 'boolean',
+                description: 'Update test snapshots (jest/vitest)',
+            },
+            timeout: {
+                type: 'number',
+                description: 'Timeout in milliseconds (default: 300000)',
+            },
+            dryRun: {
+                type: 'boolean',
+                description: 'Detect test framework and return command without executing (default: false)',
+            },
+        },
+        required: [],
+    },
+    execute: executeRunTests,
+});
+/**
+ * Execute run tests
+ */
+async function executeRunTests(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 test framework
+        let framework;
+        for (const fw of TEST_FRAMEWORKS) {
+            if (fw.detect(entries, packageJson)) {
+                framework = fw;
+                break;
+            }
+        }
+        if (!framework) {
+            return createErrorResult('No test framework detected. Supported: vitest, jest, mocha, ava, pytest, cargo test, go test, npm test script.');
+        }
+        // Build command
+        const template = framework.getCommand(input);
+        const { command, args } = buildCommand(template);
+        const commandString = formatCommand(command, args);
+        // Dry run - return detected info without executing
+        if (input.dryRun) {
+            const testResult = {
+                command: commandString,
+                output: '(dry run - command not executed)',
+                exitCode: 0,
+                duration: 0,
+                success: true,
+                framework: framework.name,
+            };
+            return createSuccessResult(testResult);
+        }
+        // Run tests
+        const result = await runCommand(command, args, {
+            cwd: targetPath,
+            timeout,
+            env: {
+                FORCE_COLOR: '1',
+                CI: 'true',
+            },
+        });
+        // Combine output
+        const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
+        // Parse test counts from output (best effort)
+        const counts = parseTestCounts(output, framework.name);
+        const testResult = {
+            command: commandString,
+            output,
+            exitCode: result.exitCode,
+            duration: result.duration,
+            success: result.exitCode === 0,
+            framework: framework.name,
+            ...counts,
+        };
+        return createSuccessResult(testResult);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Parse test counts from output (best effort)
+ */
+function parseTestCounts(output, _framework) {
+    const counts = {};
+    // Vitest pattern: "✓ 70 tests passed"
+    const vitestMatch = output.match(/(\d+)\s+tests?\s+passed/i);
+    if (vitestMatch)
+        counts.passed = parseInt(vitestMatch[1], 10);
+    const vitestFailMatch = output.match(/(\d+)\s+tests?\s+failed/i);
+    if (vitestFailMatch)
+        counts.failed = parseInt(vitestFailMatch[1], 10);
+    // Jest pattern: "Tests: 5 passed, 1 failed, 6 total"
+    const jestMatch = output.match(/Tests:\s+(\d+)\s+passed,?\s*(\d+)?\s*failed?,?\s*(\d+)?\s*skipped?,?\s*(\d+)?\s*total/i);
+    if (jestMatch) {
+        counts.passed = parseInt(jestMatch[1], 10);
+        if (jestMatch[2])
+            counts.failed = parseInt(jestMatch[2], 10);
+        if (jestMatch[3])
+            counts.skipped = parseInt(jestMatch[3], 10);
+        if (jestMatch[4])
+            counts.total = parseInt(jestMatch[4], 10);
+    }
+    // pytest pattern: "5 passed, 1 failed"
+    const pytestPassMatch = output.match(/(\d+)\s+passed/i);
+    if (pytestPassMatch)
+        counts.passed = parseInt(pytestPassMatch[1], 10);
+    const pytestFailMatch = output.match(/(\d+)\s+failed/i);
+    if (pytestFailMatch)
+        counts.failed = parseInt(pytestFailMatch[1], 10);
+    const pytestSkipMatch = output.match(/(\d+)\s+skipped/i);
+    if (pytestSkipMatch)
+        counts.skipped = parseInt(pytestSkipMatch[1], 10);
+    // Go test pattern: "ok" or "FAIL"
+    const goOkMatch = output.match(/^ok\s+/gm);
+    if (goOkMatch)
+        counts.passed = goOkMatch.length;
+    const goFailMatch = output.match(/^FAIL\s+/gm);
+    if (goFailMatch)
+        counts.failed = goFailMatch.length;
+    // Cargo test pattern: "test result: ok. 10 passed; 0 failed"
+    const cargoMatch = output.match(/(\d+)\s+passed;\s+(\d+)\s+failed/);
+    if (cargoMatch) {
+        counts.passed = parseInt(cargoMatch[1], 10);
+        counts.failed = parseInt(cargoMatch[2], 10);
+    }
+    // Calculate total if we have passed and failed
+    if (counts.passed !== undefined || counts.failed !== undefined) {
+        counts.total = (counts.passed ?? 0) + (counts.failed ?? 0) + (counts.skipped ?? 0);
+    }
+    return counts;
+}
+/**
+ * Factory function to create run tests tool with custom options
+ */
+export function createRunTestsTool(options) {
+    return defineTool({
+        name: 'run_tests',
+        description: 'Run tests using the auto-detected test framework. ' +
+            'Supports vitest, jest, mocha, ava, pytest, cargo test, go test.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory (default: current directory)',
+                },
+                pattern: {
+                    type: 'string',
+                    description: 'Test file pattern or test name filter',
+                },
+                watch: {
+                    type: 'boolean',
+                    description: 'Run in watch mode',
+                },
+                verbose: {
+                    type: 'boolean',
+                    description: 'Verbose output',
+                },
+                coverage: {
+                    type: 'boolean',
+                    description: 'Generate coverage report',
+                },
+                updateSnapshots: {
+                    type: 'boolean',
+                    description: 'Update test snapshots',
+                },
+                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 executeRunTests({
+                ...input,
+                path: targetPath,
+                timeout: input.timeout ?? options?.defaultTimeout,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,97 @@
+/**
+ * Types for Smart Runner Tools
+ */
+export interface BaseRunnerInput {
+    /** Working directory path (default: current directory) */
+    path?: string;
+    /** Timeout in milliseconds (default: 300000 = 5 min) */
+    timeout?: number;
+    /** Dry run - detect and return command without executing (default: false) */
+    dryRun?: boolean;
+}
+export interface BaseRunnerResult {
+    /** Command that was executed */
+    command: string;
+    /** Command output (stdout + stderr) */
+    output: string;
+    /** Exit code */
+    exitCode: number;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Whether the command succeeded (exitCode === 0) */
+    success: boolean;
+}
+export interface RunTestsInput extends BaseRunnerInput {
+    /** Specific test file or pattern to run */
+    pattern?: string;
+    /** Run in watch mode (if supported) */
+    watch?: boolean;
+    /** Verbose output */
+    verbose?: boolean;
+    /** Generate coverage report */
+    coverage?: boolean;
+    /** Update snapshots (for jest/vitest) */
+    updateSnapshots?: boolean;
+}
+export interface RunTestsResult extends BaseRunnerResult {
+    /** Number of tests passed (if parseable) */
+    passed?: number;
+    /** Number of tests failed (if parseable) */
+    failed?: number;
+    /** Number of tests skipped (if parseable) */
+    skipped?: number;
+    /** Total number of tests (if parseable) */
+    total?: number;
+    /** Detected test framework */
+    framework: string;
+}
+export interface RunLintInput extends BaseRunnerInput {
+    /** Specific files to lint */
+    files?: string[];
+    /** Auto-fix issues (if supported) */
+    fix?: boolean;
+    /** Output format (json, stylish, etc.) */
+    format?: string;
+}
+export interface RunLintResult extends BaseRunnerResult {
+    /** Number of errors (if parseable) */
+    errors?: number;
+    /** Number of warnings (if parseable) */
+    warnings?: number;
+    /** Detected linter */
+    linter: string;
+}
+export interface RunBuildInput extends BaseRunnerInput {
+    /** Build for production (optimized) */
+    production?: boolean;
+    /** Clean before build */
+    clean?: boolean;
+}
+export interface RunBuildResult extends BaseRunnerResult {
+    /** Detected build tool */
+    buildTool: string;
+}
+export interface RunFormatInput extends BaseRunnerInput {
+    /** Specific files to format */
+    files?: string[];
+    /** Check only, don't write changes */
+    check?: boolean;
+}
+export interface RunFormatResult extends BaseRunnerResult {
+    /** Number of files formatted/checked (if parseable) */
+    filesProcessed?: number;
+    /** Detected formatter */
+    formatter: string;
+}
+export interface CommandTemplate {
+    /** Base command */
+    command: string;
+    /** Arguments to add */
+    args: string[];
+    /** Whether this uses npm/npx */
+    useNpx?: boolean;
+    /** Whether this uses package.json scripts */
+    useScript?: boolean;
+    /** Script name for npm run */
+    scriptName?: string;
+}

package/dist/tools/runners/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for Smart Runner Tools
+ */
+export {};

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

@@ -0,0 +1,69 @@
+/**
+ * Shared utilities for Smart Runner Tools
+ */
+import type { CommandTemplate } from './types.js';
+/**
+ * Default timeout for runner commands (5 minutes)
+ */
+export declare const DEFAULT_TIMEOUT = 300000;
+/**
+ * Maximum output size (50KB)
+ */
+export declare const MAX_OUTPUT_SIZE: number;
+/**
+ * Package.json content type
+ */
+export interface PackageJsonContent {
+    name?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+}
+/**
+ * Check if directory exists
+ */
+export declare function isDirectory(path: string): Promise<boolean>;
+/**
+ * Read package.json from a directory
+ */
+export declare function readPackageJson(dirPath: string): Promise<PackageJsonContent | null>;
+/**
+ * List directory entries
+ */
+export declare function listDirectory(dirPath: string): Promise<string[]>;
+/**
+ * Check if a file exists in directory
+ */
+export declare function hasFile(entries: string[], pattern: string): boolean;
+/**
+ * Check if a dependency exists in package.json
+ */
+export declare function hasDependency(packageJson: PackageJsonContent | null, dep: string): boolean;
+/**
+ * Check if a script exists in package.json
+ */
+export declare function hasScript(packageJson: PackageJsonContent | null, script: string): boolean;
+/**
+ * Run a command and capture output
+ */
+export declare function runCommand(command: string, args: string[], options: {
+    cwd: string;
+    timeout: number;
+    env?: Record<string, string>;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}>;
+/**
+ * Build command from template
+ */
+export declare function buildCommand(template: CommandTemplate): {
+    command: string;
+    args: string[];
+};
+/**
+ * Format command for display
+ */
+export declare function formatCommand(command: string, args: string[]): string;