@compilr-dev/agents-coding 0.0.1

package/dist/tools/runners/format.js

@@ -0,0 +1,376 @@
+/**
+ * Run Format Tool
+ * Auto-detect and run formatter 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 FORMATTERS = [
+    // Prettier (Node.js)
+    {
+        name: 'prettier',
+        detect: (entries, pkg) => hasFile(entries, '.prettierrc') ||
+            hasFile(entries, '.prettierrc.js') ||
+            hasFile(entries, '.prettierrc.json') ||
+            hasFile(entries, '.prettierrc.yaml') ||
+            hasFile(entries, '.prettierrc.yml') ||
+            hasFile(entries, 'prettier.config.js') ||
+            hasFile(entries, 'prettier.config.mjs') ||
+            hasDependency(pkg, 'prettier'),
+        getCommand: (input) => {
+            const args = ['prettier'];
+            if (input.check) {
+                args.push('--check');
+            }
+            else {
+                args.push('--write');
+            }
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            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', 'format'];
+            if (!input.check) {
+                args.push('--write');
+            }
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // dprint (Node.js)
+    {
+        name: 'dprint',
+        detect: (entries, pkg) => hasFile(entries, 'dprint.json') ||
+            hasFile(entries, '.dprint.json') ||
+            hasDependency(pkg, 'dprint'),
+        getCommand: (input) => {
+            const args = ['dprint'];
+            if (input.check) {
+                args.push('check');
+            }
+            else {
+                args.push('fmt');
+            }
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // npm format script fallback (Node.js)
+    {
+        name: 'npm format',
+        detect: (_entries, pkg) => hasScript(pkg, 'format'),
+        getCommand: (input) => {
+            if (input.check && hasScript(null, 'format:check')) {
+                return {
+                    command: 'npm',
+                    args: ['run', 'format:check'],
+                    useScript: true,
+                    scriptName: 'format:check',
+                };
+            }
+            return { command: 'npm', args: ['run', 'format'], useScript: true, scriptName: 'format' };
+        },
+    },
+    // Black (Python)
+    {
+        name: 'black',
+        detect: (entries) => hasFile(entries, 'pyproject.toml') || hasFile(entries, '.black'),
+        getCommand: (input) => {
+            const args = [];
+            if (input.check)
+                args.push('--check');
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            return { command: 'black', args };
+        },
+    },
+    // Ruff format (Python)
+    {
+        name: 'ruff format',
+        detect: (entries) => hasFile(entries, 'ruff.toml') || hasFile(entries, '.ruff.toml'),
+        getCommand: (input) => {
+            const args = ['format'];
+            if (input.check)
+                args.push('--check');
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            return { command: 'ruff', args };
+        },
+    },
+    // autopep8 (Python)
+    {
+        name: 'autopep8',
+        detect: (entries) => hasFile(entries, '.pep8') || hasFile(entries, 'setup.cfg'),
+        getCommand: (input) => {
+            const args = [];
+            if (input.check) {
+                args.push('--diff');
+            }
+            else {
+                args.push('--in-place');
+            }
+            args.push('--recursive');
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            return { command: 'autopep8', args };
+        },
+    },
+    // rustfmt (Rust)
+    {
+        name: 'rustfmt',
+        detect: (entries) => hasFile(entries, 'Cargo.toml'),
+        getCommand: (input) => {
+            const args = ['fmt'];
+            if (input.check)
+                args.push('--check');
+            return { command: 'cargo', args };
+        },
+    },
+    // gofmt (Go)
+    {
+        name: 'gofmt',
+        detect: (entries) => hasFile(entries, 'go.mod'),
+        getCommand: (input) => {
+            const args = [];
+            if (input.check) {
+                args.push('-l');
+            }
+            else {
+                args.push('-w');
+            }
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            return { command: 'gofmt', args };
+        },
+    },
+    // goimports (Go) - preferred over gofmt
+    {
+        name: 'goimports',
+        detect: (entries) => hasFile(entries, 'go.mod'),
+        getCommand: (input) => {
+            const args = [];
+            if (input.check) {
+                args.push('-l');
+            }
+            else {
+                args.push('-w');
+            }
+            if (input.files && input.files.length > 0) {
+                args.push(...input.files);
+            }
+            else {
+                args.push('.');
+            }
+            return { command: 'goimports', args };
+        },
+    },
+];
+/**
+ * Run Format Tool
+ */
+export const runFormatTool = defineTool({
+    name: 'run_format',
+    description: 'Run formatter using the auto-detected formatting tool. ' +
+        'Supports Prettier, Biome, dprint, Black, Ruff, rustfmt, gofmt, and npm format scripts. ' +
+        "Options: files (specific files), check (check only, don't write).",
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory (default: current directory)',
+            },
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Specific files to format',
+            },
+            check: {
+                type: 'boolean',
+                description: "Check only, don't write changes",
+            },
+            timeout: {
+                type: 'number',
+                description: 'Timeout in milliseconds (default: 300000)',
+            },
+            dryRun: {
+                type: 'boolean',
+                description: 'Detect formatter and return command without executing (default: false)',
+            },
+        },
+        required: [],
+    },
+    execute: executeRunFormat,
+});
+/**
+ * Execute run format
+ */
+async function executeRunFormat(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 formatter
+        let formatter;
+        for (const f of FORMATTERS) {
+            if (f.detect(entries, packageJson)) {
+                formatter = f;
+                break;
+            }
+        }
+        if (!formatter) {
+            return createErrorResult('No formatter detected. Supported: Prettier, Biome, dprint, Black, Ruff, rustfmt, gofmt, npm format script.');
+        }
+        // Build command
+        const template = formatter.getCommand(input);
+        const { command, args } = buildCommand(template);
+        const commandString = formatCommand(command, args);
+        // Dry run - return detected info without executing
+        if (input.dryRun) {
+            const formatResult = {
+                command: commandString,
+                output: '(dry run - command not executed)',
+                exitCode: 0,
+                duration: 0,
+                success: true,
+                formatter: formatter.name,
+            };
+            return createSuccessResult(formatResult);
+        }
+        // Run formatter
+        const result = await runCommand(command, args, {
+            cwd: targetPath,
+            timeout,
+        });
+        // Combine output
+        const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
+        // Parse file count from output (best effort)
+        const filesProcessed = parseFormatFileCount(output, formatter.name);
+        const formatResult = {
+            command: commandString,
+            output,
+            exitCode: result.exitCode,
+            duration: result.duration,
+            success: result.exitCode === 0,
+            formatter: formatter.name,
+            filesProcessed,
+        };
+        return createSuccessResult(formatResult);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Parse file count from format output (best effort)
+ */
+function parseFormatFileCount(output, _formatter) {
+    // Prettier pattern: "N files changed" or lists files
+    const prettierMatch = output.match(/(\d+)\s+files?\s+(changed|formatted)/i);
+    if (prettierMatch) {
+        return parseInt(prettierMatch[1], 10);
+    }
+    // Count lines that look like file paths
+    const fileLines = output.split('\n').filter((line) => {
+        // Skip empty lines and common noise
+        const trimmed = line.trim();
+        if (!trimmed)
+            return false;
+        if (trimmed.startsWith('['))
+            return false; // Log prefixes
+        if (trimmed.startsWith('Checking') || trimmed.startsWith('Formatting'))
+            return false;
+        // Check if line looks like a file path
+        return /\.(ts|tsx|js|jsx|py|rs|go|java|json|md|css|scss|html)$/i.test(trimmed);
+    });
+    if (fileLines.length > 0) {
+        return fileLines.length;
+    }
+    return undefined;
+}
+/**
+ * Factory function to create run format tool with custom options
+ */
+export function createRunFormatTool(options) {
+    return defineTool({
+        name: 'run_format',
+        description: 'Run formatter using the auto-detected formatting tool. ' +
+            'Supports Prettier, Biome, dprint, Black, Ruff, rustfmt, gofmt.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory (default: current directory)',
+                },
+                files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific files to format',
+                },
+                check: {
+                    type: 'boolean',
+                    description: "Check only, don't write changes",
+                },
+                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 executeRunFormat({
+                ...input,
+                path: targetPath,
+                timeout: input.timeout ?? options?.defaultTimeout,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Smart Runner Tools
+ * Auto-detect and run tests, lint, build, and format
+ */
+export { runTestsTool, createRunTestsTool } from './test.js';
+export { runLintTool, createRunLintTool } from './lint.js';
+export { runBuildTool, createRunBuildTool } from './build.js';
+export { runFormatTool, createRunFormatTool } from './format.js';
+export type { BaseRunnerInput, BaseRunnerResult, RunTestsInput, RunTestsResult, RunLintInput, RunLintResult, RunBuildInput, RunBuildResult, RunFormatInput, RunFormatResult, } from './types.js';

package/dist/tools/runners/index.js

@@ -0,0 +1,9 @@
+/**
+ * Smart Runner Tools
+ * Auto-detect and run tests, lint, build, and format
+ */
+// Tools
+export { runTestsTool, createRunTestsTool } from './test.js';
+export { runLintTool, createRunLintTool } from './lint.js';
+export { runBuildTool, createRunBuildTool } from './build.js';
+export { runFormatTool, createRunFormatTool } from './format.js';

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

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