@compilr-dev/agents-coding 0.0.1

package/dist/tools/runners/utils.js

@@ -0,0 +1,179 @@
+/**
+ * Shared utilities for Smart Runner Tools
+ */
+import { spawn } from 'node:child_process';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Default timeout for runner commands (5 minutes)
+ */
+export const DEFAULT_TIMEOUT = 300000;
+/**
+ * Maximum output size (50KB)
+ */
+export const MAX_OUTPUT_SIZE = 50 * 1024;
+/**
+ * Check if directory exists
+ */
+export async function isDirectory(path) {
+    try {
+        const stats = await stat(path);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read package.json from a directory
+ */
+export async function readPackageJson(dirPath) {
+    try {
+        const content = await readFile(join(dirPath, 'package.json'), 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List directory entries
+ */
+export async function listDirectory(dirPath) {
+    try {
+        return await readdir(dirPath);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if a file exists in directory
+ */
+export function hasFile(entries, pattern) {
+    if (pattern.includes('*')) {
+        const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+        return entries.some((e) => regex.test(e));
+    }
+    return entries.includes(pattern);
+}
+/**
+ * Check if a dependency exists in package.json
+ */
+export function hasDependency(packageJson, dep) {
+    if (!packageJson)
+        return false;
+    return !!(packageJson.dependencies?.[dep] || packageJson.devDependencies?.[dep]);
+}
+/**
+ * Check if a script exists in package.json
+ */
+export function hasScript(packageJson, script) {
+    if (!packageJson)
+        return false;
+    return !!packageJson.scripts?.[script];
+}
+/**
+ * Run a command and capture output
+ */
+export async function runCommand(command, args, options) {
+    return new Promise((resolve) => {
+        const startTime = Date.now();
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const proc = spawn(command, args, {
+            cwd: options.cwd,
+            shell: true,
+            env: { ...process.env, ...options.env },
+        });
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            proc.kill('SIGTERM');
+            setTimeout(() => {
+                if (!proc.killed) {
+                    proc.kill('SIGKILL');
+                }
+            }, 5000);
+        }, options.timeout);
+        proc.stdout.on('data', (data) => {
+            const chunk = data.toString();
+            if (stdout.length + chunk.length <= MAX_OUTPUT_SIZE) {
+                stdout += chunk;
+            }
+            else if (stdout.length < MAX_OUTPUT_SIZE) {
+                stdout += chunk.slice(0, MAX_OUTPUT_SIZE - stdout.length);
+                stdout += '\n... (output truncated)';
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            const chunk = data.toString();
+            if (stderr.length + chunk.length <= MAX_OUTPUT_SIZE) {
+                stderr += chunk;
+            }
+            else if (stderr.length < MAX_OUTPUT_SIZE) {
+                stderr += chunk.slice(0, MAX_OUTPUT_SIZE - stderr.length);
+                stderr += '\n... (output truncated)';
+            }
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timeout);
+            const duration = Date.now() - startTime;
+            if (timedOut) {
+                stderr += `\n(Process killed: timeout after ${String(options.timeout)}ms)`;
+            }
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code ?? (timedOut ? 124 : 1),
+                duration,
+            });
+        });
+        proc.on('error', (error) => {
+            clearTimeout(timeout);
+            const duration = Date.now() - startTime;
+            resolve({
+                stdout,
+                stderr: error.message,
+                exitCode: 1,
+                duration,
+            });
+        });
+    });
+}
+/**
+ * Build command from template
+ */
+export function buildCommand(template) {
+    if (template.useScript && template.scriptName) {
+        // Use npm run script
+        return {
+            command: 'npm',
+            args: ['run', template.scriptName, ...template.args],
+        };
+    }
+    if (template.useNpx) {
+        // Use npx to run the command
+        return {
+            command: 'npx',
+            args: [template.command, ...template.args],
+        };
+    }
+    // Direct command
+    return {
+        command: template.command,
+        args: template.args,
+    };
+}
+/**
+ * Format command for display
+ */
+export function formatCommand(command, args) {
+    const escapedArgs = args.map((arg) => {
+        if (arg.includes(' ') || arg.includes('"')) {
+            return `"${arg.replace(/"/g, '\\"')}"`;
+        }
+        return arg;
+    });
+    return `${command} ${escapedArgs.join(' ')}`.trim();
+}

package/dist/tools/search/definition.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Find Definition Tool
+ * Find where a symbol is defined using regex patterns
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { FindDefinitionInput } from './types.js';
+/**
+ * Find Definition Tool
+ */
+export declare const findDefinitionTool: Tool<FindDefinitionInput>;
+/**
+ * Factory function to create find definition tool with custom options
+ */
+export declare function createFindDefinitionTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+    /** Default limit */
+    defaultLimit?: number;
+}): Tool<FindDefinitionInput>;

package/dist/tools/search/definition.js

@@ -0,0 +1,305 @@
+/**
+ * Find Definition Tool
+ * Find where a symbol is defined using regex patterns
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { escapeRegex, isDirectory, runGrep } from './utils.js';
+const DEFINITION_PATTERNS = [
+    // TypeScript/JavaScript - Functions
+    {
+        pattern: '(export\\s+)?(async\\s+)?function\\s+{symbol}\\s*[(<]',
+        type: 'function',
+        extensions: ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs'],
+        checkExport: true,
+    },
+    {
+        pattern: '(export\\s+)?(const|let|var)\\s+{symbol}\\s*=\\s*(async\\s+)?\\([^)]*\\)\\s*=>',
+        type: 'function',
+        extensions: ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs'],
+        checkExport: true,
+    },
+    {
+        pattern: '(export\\s+)?(const|let|var)\\s+{symbol}\\s*=\\s*(async\\s+)?function',
+        type: 'function',
+        extensions: ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs'],
+        checkExport: true,
+    },
+    // TypeScript/JavaScript - Classes
+    {
+        pattern: '(export\\s+)?(abstract\\s+)?class\\s+{symbol}\\s*[{<]',
+        type: 'class',
+        extensions: ['ts', 'tsx', 'js', 'jsx'],
+        checkExport: true,
+    },
+    // TypeScript - Interfaces and Types
+    {
+        pattern: '(export\\s+)?interface\\s+{symbol}\\s*[{<]',
+        type: 'interface',
+        extensions: ['ts', 'tsx'],
+        checkExport: true,
+    },
+    {
+        pattern: '(export\\s+)?type\\s+{symbol}\\s*[=<]',
+        type: 'type',
+        extensions: ['ts', 'tsx'],
+        checkExport: true,
+    },
+    // TypeScript/JavaScript - Constants and Variables
+    {
+        pattern: '(export\\s+)?const\\s+{symbol}\\s*[=:]',
+        type: 'const',
+        extensions: ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs'],
+        checkExport: true,
+    },
+    {
+        pattern: '(export\\s+)?let\\s+{symbol}\\s*[=:]',
+        type: 'let',
+        extensions: ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs'],
+        checkExport: true,
+    },
+    // TypeScript - Enums
+    {
+        pattern: '(export\\s+)?(const\\s+)?enum\\s+{symbol}\\s*\\{',
+        type: 'enum',
+        extensions: ['ts', 'tsx'],
+        checkExport: true,
+    },
+    // Python - Functions
+    {
+        pattern: '(async\\s+)?def\\s+{symbol}\\s*\\(',
+        type: 'function',
+        extensions: ['py'],
+    },
+    // Python - Classes
+    {
+        pattern: 'class\\s+{symbol}\\s*[:(]',
+        type: 'class',
+        extensions: ['py'],
+    },
+    // Rust - Functions
+    {
+        pattern: '(pub\\s+)?(async\\s+)?fn\\s+{symbol}\\s*[(<]',
+        type: 'function',
+        extensions: ['rs'],
+    },
+    // Rust - Structs
+    {
+        pattern: '(pub\\s+)?struct\\s+{symbol}\\s*[{<(;]',
+        type: 'class',
+        extensions: ['rs'],
+    },
+    // Rust - Enums
+    {
+        pattern: '(pub\\s+)?enum\\s+{symbol}\\s*[{<]',
+        type: 'enum',
+        extensions: ['rs'],
+    },
+    // Rust - Traits
+    {
+        pattern: '(pub\\s+)?trait\\s+{symbol}\\s*[{<:]',
+        type: 'interface',
+        extensions: ['rs'],
+    },
+    // Rust - Type aliases
+    {
+        pattern: '(pub\\s+)?type\\s+{symbol}\\s*[=<]',
+        type: 'type',
+        extensions: ['rs'],
+    },
+    // Go - Functions
+    {
+        pattern: 'func\\s+{symbol}\\s*\\(',
+        type: 'function',
+        extensions: ['go'],
+    },
+    // Go - Methods (with receiver)
+    {
+        pattern: 'func\\s+\\([^)]+\\)\\s+{symbol}\\s*\\(',
+        type: 'method',
+        extensions: ['go'],
+    },
+    // Go - Types
+    {
+        pattern: 'type\\s+{symbol}\\s+(struct|interface|func|map|\\[)',
+        type: 'type',
+        extensions: ['go'],
+    },
+    // Go - Const/Var
+    {
+        pattern: '(const|var)\\s+{symbol}\\s*[=:]',
+        type: 'variable',
+        extensions: ['go'],
+    },
+    // Java/Kotlin - Classes
+    {
+        pattern: '(public\\s+|private\\s+|protected\\s+)?(abstract\\s+|final\\s+)?class\\s+{symbol}\\s*[{<]',
+        type: 'class',
+        extensions: ['java', 'kt'],
+    },
+    // Java/Kotlin - Interfaces
+    {
+        pattern: '(public\\s+|private\\s+)?interface\\s+{symbol}\\s*[{<]',
+        type: 'interface',
+        extensions: ['java', 'kt'],
+    },
+    // Java - Methods
+    {
+        pattern: '(public|private|protected)\\s+[\\w<>\\[\\]]+\\s+{symbol}\\s*\\(',
+        type: 'method',
+        extensions: ['java'],
+    },
+];
+/**
+ * Run grep/ripgrep to find definitions
+ */
+async function searchDefinitions(symbol, cwd, fileType, limit = 20) {
+    const escapedSymbol = escapeRegex(symbol);
+    const definitions = [];
+    // Filter patterns by file type if specified
+    const patterns = fileType
+        ? DEFINITION_PATTERNS.filter((p) => p.extensions.includes(fileType))
+        : DEFINITION_PATTERNS;
+    // Build glob pattern for file types
+    const extensions = fileType
+        ? [fileType]
+        : [...new Set(DEFINITION_PATTERNS.flatMap((p) => p.extensions))];
+    const globPattern = extensions.length === 1 ? `**/*.${extensions[0]}` : `**/*.{${extensions.join(',')}}`;
+    for (const pattern of patterns) {
+        if (definitions.length >= limit)
+            break;
+        const regexPattern = pattern.pattern.replace('{symbol}', escapedSymbol);
+        try {
+            const args = ['-n', '--column', '--glob', globPattern, '-e', regexPattern, '.'];
+            const results = await runGrep(args, cwd, limit - definitions.length, true);
+            for (const result of results) {
+                // Check if file extension matches this pattern
+                const ext = result.file.split('.').pop() ?? '';
+                if (!pattern.extensions.includes(ext))
+                    continue;
+                // Check if already found this location
+                const exists = definitions.some((d) => d.file === result.file && d.line === result.line);
+                if (exists)
+                    continue;
+                // Determine export status
+                const isExported = pattern.checkExport
+                    ? /^(export\s+|pub\s+)/.test(result.context.trim())
+                    : undefined;
+                definitions.push({
+                    file: result.file,
+                    line: result.line,
+                    column: result.column ?? 1,
+                    context: result.context.trim(),
+                    type: pattern.type,
+                    isExported,
+                });
+                if (definitions.length >= limit)
+                    break;
+            }
+        }
+        catch {
+            // Ignore grep errors, continue with other patterns
+        }
+    }
+    return definitions;
+}
+/**
+ * Execute find definition
+ */
+async function executeFindDefinition(input) {
+    const targetPath = input.path ?? process.cwd();
+    const limit = input.limit ?? 20;
+    if (!input.symbol || input.symbol.trim().length === 0) {
+        return createErrorResult('Symbol is required');
+    }
+    if (!(await isDirectory(targetPath))) {
+        return createErrorResult(`Directory not found: ${targetPath}`);
+    }
+    try {
+        const definitions = await searchDefinitions(input.symbol.trim(), targetPath, input.fileType, limit);
+        const result = {
+            definitions,
+            totalFound: definitions.length,
+            symbol: input.symbol.trim(),
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Find Definition Tool
+ */
+export const findDefinitionTool = defineTool({
+    name: 'find_definition',
+    description: 'Find where a symbol is defined in the codebase. ' +
+        'Searches for function, class, interface, type, const, enum definitions. ' +
+        'Supports TypeScript, JavaScript, Python, Rust, Go, Java, Kotlin.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            symbol: {
+                type: 'string',
+                description: 'Symbol name to find (e.g., function name, class name)',
+            },
+            path: {
+                type: 'string',
+                description: 'Working directory (default: current directory)',
+            },
+            fileType: {
+                type: 'string',
+                description: 'File type filter (e.g., ts, py, rs, go)',
+            },
+            limit: {
+                type: 'number',
+                description: 'Max results (default: 20)',
+            },
+        },
+        required: ['symbol'],
+    },
+    execute: executeFindDefinition,
+});
+/**
+ * Factory function to create find definition tool with custom options
+ */
+export function createFindDefinitionTool(options) {
+    return defineTool({
+        name: 'find_definition',
+        description: 'Find where a symbol is defined in the codebase. ' +
+            'Supports TypeScript, JavaScript, Python, Rust, Go, Java, Kotlin.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                symbol: {
+                    type: 'string',
+                    description: 'Symbol name to find',
+                },
+                path: {
+                    type: 'string',
+                    description: 'Working directory',
+                },
+                fileType: {
+                    type: 'string',
+                    description: 'File type filter',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results',
+                },
+            },
+            required: ['symbol'],
+        },
+        execute: async (input) => {
+            let targetPath = input.path ?? '.';
+            if (options?.baseDir && !targetPath.startsWith('/')) {
+                const nodePath = await import('node:path');
+                targetPath = nodePath.join(options.baseDir, targetPath);
+            }
+            return executeFindDefinition({
+                ...input,
+                path: targetPath,
+                limit: input.limit ?? options?.defaultLimit,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Code Search Tools
+ * Find definitions, references, and TODO comments
+ */
+export { findDefinitionTool, createFindDefinitionTool } from './definition.js';
+export { findReferencesTool, createFindReferencesTool } from './references.js';
+export { findTodosTool, createFindTodosTool } from './todos.js';
+export type { DefinitionType, Definition, FindDefinitionInput, FindDefinitionResult, Reference, FindReferencesInput, FindReferencesResult, TodoType, TodoComment, FindTodosInput, FindTodosResult, } from './types.js';

package/dist/tools/search/index.js

@@ -0,0 +1,8 @@
+/**
+ * Code Search Tools
+ * Find definitions, references, and TODO comments
+ */
+// Tools
+export { findDefinitionTool, createFindDefinitionTool } from './definition.js';
+export { findReferencesTool, createFindReferencesTool } from './references.js';
+export { findTodosTool, createFindTodosTool } from './todos.js';

package/dist/tools/search/references.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Find References Tool
+ * Find usages of a symbol using grep with word boundary matching
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { FindReferencesInput } from './types.js';
+/**
+ * Find References Tool
+ */
+export declare const findReferencesTool: Tool<FindReferencesInput>;
+/**
+ * Factory function to create find references tool with custom options
+ */
+export declare function createFindReferencesTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+    /** Default limit */
+    defaultLimit?: number;
+}): Tool<FindReferencesInput>;