@compilr-dev/agents-coding 0.0.1

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

@@ -0,0 +1,83 @@
+/**
+ * Types for project detection tools
+ */
+/**
+ * Detected project types
+ */
+export type ProjectType = 'node' | 'python' | 'rust' | 'go' | 'java' | 'ruby' | 'php' | 'dotnet' | 'unknown';
+/**
+ * Package managers by project type
+ */
+export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'pip' | 'poetry' | 'cargo' | 'go' | 'maven' | 'gradle' | 'bundler' | 'composer' | 'dotnet';
+/**
+ * Input for detectProject tool
+ */
+export interface DetectProjectInput {
+    /** Directory to analyze (default: current directory) */
+    path?: string;
+}
+/**
+ * Result of project detection
+ */
+export interface DetectProjectResult {
+    /** Primary project type */
+    type: ProjectType;
+    /** All detected types (for monorepos or multi-language projects) */
+    types: ProjectType[];
+    /** Package manager detected */
+    packageManager?: PackageManager;
+    /** Test framework detected */
+    testFramework?: string;
+    /** Linter detected */
+    linter?: string;
+    /** Formatter detected */
+    formatter?: string;
+    /** Build tool detected */
+    buildTool?: string;
+    /** Config files found */
+    configFiles: string[];
+    /** Project name (if detectable) */
+    name?: string;
+}
+/**
+ * Input for findProjectRoot tool
+ */
+export interface FindProjectRootInput {
+    /** Starting directory (default: current directory) */
+    path?: string;
+    /** Marker files to look for */
+    markers?: string[];
+}
+/**
+ * Result of finding project root
+ */
+export interface FindProjectRootResult {
+    /** Project root path */
+    root: string;
+    /** Marker file that was found */
+    foundMarker: string;
+    /** Distance from starting path (0 = same directory) */
+    depth: number;
+}
+/**
+ * Project detection rule
+ */
+export interface ProjectDetectionRule {
+    type: ProjectType;
+    files: string[];
+    packageManager?: PackageManager;
+    priority: number;
+}
+/**
+ * Tool detection rule
+ */
+export interface ToolDetectionRule {
+    /** Files that indicate this tool */
+    files: string[];
+    /** Package.json dependencies that indicate this tool */
+    dependencies?: string[];
+    /** Package.json scripts that indicate this tool */
+    scripts?: string[];
+    /** Name to return when detected */
+    name: string;
+}

package/dist/tools/project/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for project detection tools
+ */
+export {};

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

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

package/dist/tools/runners/build.js

@@ -0,0 +1,306 @@
+/**
+ * Run Build Tool
+ * Auto-detect and run build 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 BUILD_TOOLS = [
+    // Vite (Node.js)
+    {
+        name: 'vite',
+        detect: (entries, pkg) => hasFile(entries, 'vite.config.ts') ||
+            hasFile(entries, 'vite.config.js') ||
+            hasFile(entries, 'vite.config.mjs') ||
+            hasDependency(pkg, 'vite'),
+        getCommand: (input) => {
+            const args = ['vite', 'build'];
+            if (input.production)
+                args.push('--mode', 'production');
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // Next.js
+    {
+        name: 'next',
+        detect: (entries, pkg) => hasFile(entries, 'next.config.js') ||
+            hasFile(entries, 'next.config.mjs') ||
+            hasFile(entries, 'next.config.ts') ||
+            hasDependency(pkg, 'next'),
+        getCommand: () => ({
+            command: 'npx',
+            args: ['next', 'build'],
+            useNpx: false,
+        }),
+    },
+    // TypeScript Compiler
+    {
+        name: 'tsc',
+        detect: (entries, pkg) => hasFile(entries, 'tsconfig.json') &&
+            (hasDependency(pkg, 'typescript') || hasScript(pkg, 'build')),
+        getCommand: (input) => {
+            const args = ['tsc'];
+            if (input.clean)
+                args.push('--build', '--clean');
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // Webpack
+    {
+        name: 'webpack',
+        detect: (entries, pkg) => hasFile(entries, 'webpack.config.js') ||
+            hasFile(entries, 'webpack.config.ts') ||
+            hasDependency(pkg, 'webpack'),
+        getCommand: (input) => {
+            const args = ['webpack'];
+            if (input.production)
+                args.push('--mode', 'production');
+            return { command: 'npx', args, useNpx: false };
+        },
+    },
+    // Rollup
+    {
+        name: 'rollup',
+        detect: (entries, pkg) => hasFile(entries, 'rollup.config.js') ||
+            hasFile(entries, 'rollup.config.mjs') ||
+            hasDependency(pkg, 'rollup'),
+        getCommand: () => ({
+            command: 'npx',
+            args: ['rollup', '-c'],
+            useNpx: false,
+        }),
+    },
+    // esbuild
+    {
+        name: 'esbuild',
+        detect: (entries, pkg) => hasFile(entries, 'esbuild.config.js') ||
+            hasFile(entries, 'esbuild.config.mjs') ||
+            hasDependency(pkg, 'esbuild'),
+        getCommand: () => ({
+            command: 'npx',
+            args: ['esbuild'],
+            useNpx: false,
+        }),
+    },
+    // Turbo (monorepo)
+    {
+        name: 'turbo',
+        detect: (entries, pkg) => hasFile(entries, 'turbo.json') || hasDependency(pkg, 'turbo'),
+        getCommand: () => ({
+            command: 'npx',
+            args: ['turbo', 'run', 'build'],
+            useNpx: false,
+        }),
+    },
+    // npm build script fallback (Node.js)
+    {
+        name: 'npm build',
+        detect: (_entries, pkg) => hasScript(pkg, 'build'),
+        getCommand: () => ({
+            command: 'npm',
+            args: ['run', 'build'],
+            useScript: true,
+            scriptName: 'build',
+        }),
+    },
+    // Cargo build (Rust)
+    {
+        name: 'cargo build',
+        detect: (entries) => hasFile(entries, 'Cargo.toml'),
+        getCommand: (input) => {
+            const args = ['build'];
+            if (input.production)
+                args.push('--release');
+            return { command: 'cargo', args };
+        },
+    },
+    // Go build
+    {
+        name: 'go build',
+        detect: (entries) => hasFile(entries, 'go.mod'),
+        getCommand: () => ({
+            command: 'go',
+            args: ['build', './...'],
+        }),
+    },
+    // Python setuptools
+    {
+        name: 'python build',
+        detect: (entries) => hasFile(entries, 'setup.py') || hasFile(entries, 'pyproject.toml'),
+        getCommand: () => ({
+            command: 'python',
+            args: ['-m', 'build'],
+        }),
+    },
+    // Maven (Java)
+    {
+        name: 'maven',
+        detect: (entries) => hasFile(entries, 'pom.xml'),
+        getCommand: (input) => {
+            const args = [];
+            if (input.clean)
+                args.push('clean');
+            args.push('package');
+            if (input.production)
+                args.push('-DskipTests');
+            return { command: 'mvn', args };
+        },
+    },
+    // Gradle (Java)
+    {
+        name: 'gradle',
+        detect: (entries) => hasFile(entries, 'build.gradle') || hasFile(entries, 'build.gradle.kts'),
+        getCommand: (input) => {
+            const args = [];
+            if (input.clean)
+                args.push('clean');
+            args.push('build');
+            return { command: './gradlew', args };
+        },
+    },
+];
+/**
+ * Run Build Tool
+ */
+export const runBuildTool = defineTool({
+    name: 'run_build',
+    description: 'Run build using the auto-detected build tool. ' +
+        'Supports Vite, Next.js, TypeScript, Webpack, Rollup, esbuild, Turbo, Cargo, Go, Python, Maven, Gradle, and npm build scripts. ' +
+        'Options: production (optimized build), clean (clean before build).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory (default: current directory)',
+            },
+            production: {
+                type: 'boolean',
+                description: 'Build for production (optimized)',
+            },
+            clean: {
+                type: 'boolean',
+                description: 'Clean before build',
+            },
+            timeout: {
+                type: 'number',
+                description: 'Timeout in milliseconds (default: 300000)',
+            },
+            dryRun: {
+                type: 'boolean',
+                description: 'Detect build tool and return command without executing (default: false)',
+            },
+        },
+        required: [],
+    },
+    execute: executeRunBuild,
+});
+/**
+ * Execute run build
+ */
+async function executeRunBuild(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 build tool
+        let buildTool;
+        for (const b of BUILD_TOOLS) {
+            if (b.detect(entries, packageJson)) {
+                buildTool = b;
+                break;
+            }
+        }
+        if (!buildTool) {
+            return createErrorResult('No build tool detected. Supported: Vite, Next.js, TypeScript, Webpack, Rollup, esbuild, Turbo, Cargo, Go, Maven, Gradle, npm build script.');
+        }
+        // Build command
+        const template = buildTool.getCommand(input);
+        const { command, args } = buildCommand(template);
+        const commandString = formatCommand(command, args);
+        // Dry run - return detected info without executing
+        if (input.dryRun) {
+            const buildResult = {
+                command: commandString,
+                output: '(dry run - command not executed)',
+                exitCode: 0,
+                duration: 0,
+                success: true,
+                buildTool: buildTool.name,
+            };
+            return createSuccessResult(buildResult);
+        }
+        // Run build
+        const result = await runCommand(command, args, {
+            cwd: targetPath,
+            timeout,
+            env: {
+                NODE_ENV: input.production ? 'production' : 'development',
+            },
+        });
+        // Combine output
+        const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
+        const buildResult = {
+            command: commandString,
+            output,
+            exitCode: result.exitCode,
+            duration: result.duration,
+            success: result.exitCode === 0,
+            buildTool: buildTool.name,
+        };
+        return createSuccessResult(buildResult);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Factory function to create run build tool with custom options
+ */
+export function createRunBuildTool(options) {
+    return defineTool({
+        name: 'run_build',
+        description: 'Run build using the auto-detected build tool. ' +
+            'Supports Vite, Next.js, TypeScript, Webpack, Rollup, esbuild, Turbo, Cargo, Go, Maven, Gradle.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory (default: current directory)',
+                },
+                production: {
+                    type: 'boolean',
+                    description: 'Build for production',
+                },
+                clean: {
+                    type: 'boolean',
+                    description: 'Clean before build',
+                },
+                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 executeRunBuild({
+                ...input,
+                path: targetPath,
+                timeout: input.timeout ?? options?.defaultTimeout,
+            });
+        },
+    });
+}

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

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