@compilr-dev/agents 0.0.1

package/dist/tools/builtin/edit.js

@@ -0,0 +1,215 @@
+/**
+ * Edit Tool - Perform targeted string replacements in files
+ */
+import { readFile, writeFile, access, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { defineTool, createSuccessResult, createErrorResult } from '../define.js';
+import { isNodeError, isExtensionAllowed, atomicWriteFile } from './utils.js';
+/**
+ * Edit tool definition
+ */
+export const editTool = defineTool({
+    name: 'edit',
+    description: 'Perform exact string replacements in files. ' +
+        'By default, the old_string must be unique in the file. ' +
+        'Use replaceAll to replace all occurrences.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            filePath: {
+                type: 'string',
+                description: 'Path to the file to edit',
+            },
+            oldString: {
+                type: 'string',
+                description: 'The text to search for and replace',
+            },
+            newString: {
+                type: 'string',
+                description: 'The replacement text',
+            },
+            replaceAll: {
+                type: 'boolean',
+                description: 'Replace all occurrences instead of requiring uniqueness',
+            },
+            createIfMissing: {
+                type: 'boolean',
+                description: 'Create the file with newString content if it does not exist',
+            },
+        },
+        required: ['filePath', 'oldString', 'newString'],
+    },
+    execute: executeEdit,
+});
+/**
+ * Execute the edit tool
+ */
+async function executeEdit(input) {
+    const { filePath, oldString, newString, replaceAll = false, createIfMissing = false } = input;
+    // Validate inputs
+    if (oldString === newString) {
+        return createErrorResult('oldString and newString are identical - no change needed');
+    }
+    if (oldString === '') {
+        return createErrorResult('oldString cannot be empty');
+    }
+    // Check if file exists
+    let fileExists = true;
+    try {
+        await access(filePath);
+    }
+    catch {
+        fileExists = false;
+    }
+    if (!fileExists) {
+        if (createIfMissing) {
+            // Create new file with the newString content
+            try {
+                // Create parent directories if they don't exist
+                const dir = dirname(filePath);
+                if (dir && dir !== '.') {
+                    await mkdir(dir, { recursive: true });
+                }
+                await writeFile(filePath, newString, 'utf-8');
+                return createSuccessResult({
+                    filePath,
+                    created: true,
+                    replacements: 0,
+                    message: `Created new file with content`,
+                });
+            }
+            catch (error) {
+                return createErrorResult(`Failed to create file: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return createErrorResult(`File not found: ${filePath}`);
+    }
+    // Read the file
+    let content;
+    try {
+        content = await readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (isNodeError(error)) {
+            switch (error.code) {
+                case 'EACCES':
+                    return createErrorResult(`Permission denied: ${filePath}`);
+                case 'EISDIR':
+                    return createErrorResult(`Path is a directory: ${filePath}`);
+                default:
+                    return createErrorResult(`Failed to read file: ${error.message}`);
+            }
+        }
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+    // Count occurrences
+    const occurrences = countOccurrences(content, oldString);
+    if (occurrences === 0) {
+        return createErrorResult(`String not found in file: "${truncate(oldString, 100)}"`);
+    }
+    if (!replaceAll && occurrences > 1) {
+        return createErrorResult(`The oldString appears ${String(occurrences)} times in the file. ` +
+            `Either provide more context to make it unique, or set replaceAll: true`);
+    }
+    // Perform the replacement
+    const newContent = replaceAll
+        ? content.split(oldString).join(newString)
+        : content.replace(oldString, newString);
+    // Write the file atomically (prevents corruption on interruption)
+    try {
+        await atomicWriteFile(filePath, newContent, 'utf-8');
+    }
+    catch (error) {
+        return createErrorResult(`Failed to write file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return createSuccessResult({
+        filePath,
+        created: false,
+        replacements: replaceAll ? occurrences : 1,
+        message: replaceAll ? `Replaced ${String(occurrences)} occurrences` : `Replaced 1 occurrence`,
+    });
+}
+/**
+ * Count occurrences of a substring
+ */
+function countOccurrences(text, search) {
+    let count = 0;
+    let position = 0;
+    let index = text.indexOf(search, position);
+    while (index !== -1) {
+        count++;
+        position = index + 1;
+        index = text.indexOf(search, position);
+    }
+    return count;
+}
+/**
+ * Truncate a string for display
+ */
+function truncate(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    return str.slice(0, maxLength - 3) + '...';
+}
+/**
+ * Factory function to create an edit tool with custom options
+ */
+export function createEditTool(options) {
+    return defineTool({
+        name: 'edit',
+        description: 'Perform exact string replacements in files. ' +
+            'By default, the old_string must be unique in the file. ' +
+            'Use replaceAll to replace all occurrences.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: {
+                    type: 'string',
+                    description: 'Path to the file to edit',
+                },
+                oldString: {
+                    type: 'string',
+                    description: 'The text to search for and replace',
+                },
+                newString: {
+                    type: 'string',
+                    description: 'The replacement text',
+                },
+                replaceAll: {
+                    type: 'boolean',
+                    description: 'Replace all occurrences instead of requiring uniqueness',
+                },
+                createIfMissing: {
+                    type: 'boolean',
+                    description: 'Create the file with newString content if it does not exist',
+                },
+            },
+            required: ['filePath', 'oldString', 'newString'],
+        },
+        execute: async (input) => {
+            let targetPath = input.filePath;
+            // Resolve relative paths
+            if (options?.baseDir && !targetPath.startsWith('/')) {
+                targetPath = `${options.baseDir}/${targetPath}`;
+            }
+            // Check allowed extensions
+            if (options?.allowedExtensions && options.allowedExtensions.length > 0) {
+                if (!isExtensionAllowed(targetPath, options.allowedExtensions)) {
+                    return createErrorResult(`File extension not allowed. Allowed: ${options.allowedExtensions.join(', ')}`);
+                }
+            }
+            // Check disallowed paths
+            if (options?.disallowedPaths) {
+                for (const disallowed of options.disallowedPaths) {
+                    if (targetPath.includes(disallowed)) {
+                        return createErrorResult(`Editing files in ${disallowed} is not allowed`);
+                    }
+                }
+            }
+            return executeEdit({
+                ...input,
+                filePath: targetPath,
+            });
+        },
+    });
+}

package/dist/tools/builtin/glob.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Glob Tool - Find files matching glob patterns
+ */
+import type { Tool } from '../types.js';
+/**
+ * Input parameters for glob tool
+ */
+export interface GlobInput {
+    /**
+     * Glob pattern to match files against (e.g., "**\/*.ts", "src/*.js")
+     */
+    pattern: string;
+    /**
+     * Base directory to search in (default: current directory)
+     */
+    path?: string;
+    /**
+     * Include hidden files and directories (default: false)
+     */
+    includeHidden?: boolean;
+    /**
+     * Only match directories (default: false)
+     */
+    onlyDirectories?: boolean;
+    /**
+     * Only match files (default: true)
+     */
+    onlyFiles?: boolean;
+    /**
+     * Maximum depth to traverse (default: unlimited)
+     */
+    maxDepth?: number;
+    /**
+     * Maximum number of results (default: 1000)
+     */
+    maxResults?: number;
+    /**
+     * Return absolute paths instead of relative (default: false)
+     */
+    absolute?: boolean;
+}
+/**
+ * Glob tool definition
+ */
+export declare const globTool: Tool<GlobInput>;
+/**
+ * Factory function to create a glob tool with custom options
+ */
+export declare function createGlobTool(options?: {
+    /**
+     * Base directory to resolve relative paths against
+     */
+    baseDir?: string;
+    /**
+     * Default patterns to ignore
+     */
+    ignorePatterns?: string[];
+    /**
+     * Always include these patterns regardless of ignore
+     */
+    alwaysInclude?: string[];
+}): Tool<GlobInput>;

package/dist/tools/builtin/glob.js

@@ -0,0 +1,244 @@
+/**
+ * Glob Tool - Find files matching glob patterns
+ */
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defineTool, createSuccessResult, createErrorResult } from '../define.js';
+import { isNodeError } from './utils.js';
+/**
+ * Glob tool definition
+ */
+export const globTool = defineTool({
+    name: 'glob',
+    description: 'Find files matching glob patterns. ' +
+        'Supports common patterns like **/*.ts for recursive matching. ' +
+        'Returns a list of matching file paths.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'Glob pattern (e.g., "**/*.ts", "src/**/*.js", "*.md")',
+            },
+            path: {
+                type: 'string',
+                description: 'Base directory to search in (default: current directory)',
+            },
+            includeHidden: {
+                type: 'boolean',
+                description: 'Include hidden files/directories (default: false)',
+            },
+            onlyDirectories: {
+                type: 'boolean',
+                description: 'Only match directories',
+            },
+            onlyFiles: {
+                type: 'boolean',
+                description: 'Only match files (default: true)',
+            },
+            maxDepth: {
+                type: 'number',
+                description: 'Maximum directory depth to traverse',
+            },
+            maxResults: {
+                type: 'number',
+                description: 'Maximum number of results (default: 1000)',
+            },
+            absolute: {
+                type: 'boolean',
+                description: 'Return absolute paths instead of relative',
+            },
+        },
+        required: ['pattern'],
+    },
+    execute: executeGlob,
+});
+/**
+ * Execute the glob tool
+ */
+async function executeGlob(input) {
+    const { pattern, path: basePath = '.', includeHidden = false, onlyDirectories = false, onlyFiles = !onlyDirectories, maxDepth, maxResults = 1000, absolute = false, } = input;
+    // Check if base path exists
+    try {
+        await readdir(basePath);
+    }
+    catch (error) {
+        if (isNodeError(error)) {
+            switch (error.code) {
+                case 'ENOENT':
+                    return createErrorResult(`Directory not found: ${basePath}`);
+                case 'EACCES':
+                    return createErrorResult(`Permission denied: ${basePath}`);
+                default:
+                    return createErrorResult(`Glob failed: ${error.message}`);
+            }
+        }
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+    try {
+        // Parse the glob pattern
+        const globRegex = patternToRegex(pattern);
+        const hasRecursive = pattern.includes('**');
+        // Collect matching files
+        const matches = [];
+        await searchDirectory(basePath, '', 0, {
+            pattern: globRegex,
+            hasRecursive,
+            includeHidden,
+            onlyDirectories,
+            onlyFiles,
+            maxDepth,
+            maxResults,
+            matches,
+            basePath,
+        });
+        // Format output
+        const results = absolute ? matches.map((m) => join(basePath, m)) : matches;
+        return createSuccessResult({
+            files: results,
+            count: results.length,
+            truncated: results.length >= maxResults,
+        });
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Recursively search a directory for matching files
+ */
+async function searchDirectory(basePath, relativePath, depth, options) {
+    // Check if we've reached max results
+    if (options.matches.length >= options.maxResults) {
+        return;
+    }
+    // Check max depth
+    if (options.maxDepth !== undefined && depth > options.maxDepth) {
+        return;
+    }
+    const currentPath = relativePath ? join(basePath, relativePath) : basePath;
+    let entries;
+    try {
+        entries = await readdir(currentPath, { withFileTypes: true });
+    }
+    catch {
+        // Skip directories we can't read
+        return;
+    }
+    for (const entry of entries) {
+        if (options.matches.length >= options.maxResults) {
+            break;
+        }
+        // Skip hidden files unless included
+        if (!options.includeHidden && entry.name.startsWith('.')) {
+            continue;
+        }
+        const entryRelativePath = relativePath ? join(relativePath, entry.name) : entry.name;
+        const isDir = entry.isDirectory();
+        const isFile = entry.isFile();
+        // Check if this entry matches the pattern
+        if (options.pattern.test(entryRelativePath)) {
+            if ((isDir && !options.onlyFiles) || (isFile && !options.onlyDirectories)) {
+                options.matches.push(entryRelativePath);
+            }
+        }
+        // Recurse into directories
+        if (isDir && (options.hasRecursive || shouldDescend(entryRelativePath, options.pattern))) {
+            await searchDirectory(basePath, entryRelativePath, depth + 1, options);
+        }
+    }
+}
+/**
+ * Check if we should descend into a directory based on the pattern
+ */
+function shouldDescend(_path, _pattern) {
+    // If the pattern might match files in this directory, descend
+    // This is a simplified check - just return true for non-** patterns
+    // that might have directory prefixes
+    return true;
+}
+/**
+ * Convert a glob pattern to a regular expression
+ */
+function patternToRegex(pattern) {
+    // Handle special case: **/* means match anything
+    if (pattern === '**/*') {
+        return new RegExp('^.+$');
+    }
+    // Handle **/ at the start first (matches any directory prefix including none)
+    let workingPattern = pattern;
+    let prefix = '';
+    if (workingPattern.startsWith('**/')) {
+        prefix = '(?:.*/|)';
+        workingPattern = workingPattern.slice(3); // Remove the **/ part
+    }
+    // Escape special regex characters except glob characters (* and ?)
+    let regexStr = workingPattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    // Handle remaining ** (matches anything including /)
+    regexStr = regexStr.replace(/\*\*/g, '.*');
+    // Handle remaining * (matches anything except /)
+    regexStr = regexStr.replace(/\*/g, '[^/]*');
+    // Handle ? (matches single character except /)
+    regexStr = regexStr.replace(/\?/g, '[^/]');
+    return new RegExp('^' + prefix + regexStr + '$');
+}
+/**
+ * Factory function to create a glob tool with custom options
+ */
+export function createGlobTool(options) {
+    return defineTool({
+        name: 'glob',
+        description: 'Find files matching glob patterns. ' +
+            'Supports common patterns like **/*.ts for recursive matching. ' +
+            'Returns a list of matching file paths.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: 'Glob pattern (e.g., "**/*.ts", "src/**/*.js", "*.md")',
+                },
+                path: {
+                    type: 'string',
+                    description: 'Base directory to search in (default: current directory)',
+                },
+                includeHidden: {
+                    type: 'boolean',
+                    description: 'Include hidden files/directories (default: false)',
+                },
+                onlyDirectories: {
+                    type: 'boolean',
+                    description: 'Only match directories',
+                },
+                onlyFiles: {
+                    type: 'boolean',
+                    description: 'Only match files (default: true)',
+                },
+                maxDepth: {
+                    type: 'number',
+                    description: 'Maximum directory depth to traverse',
+                },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum number of results (default: 1000)',
+                },
+                absolute: {
+                    type: 'boolean',
+                    description: 'Return absolute paths instead of relative',
+                },
+            },
+            required: ['pattern'],
+        },
+        execute: async (input) => {
+            let searchPath = input.path ?? '.';
+            // Resolve relative paths
+            if (options?.baseDir && !searchPath.startsWith('/')) {
+                searchPath = join(options.baseDir, searchPath);
+            }
+            return executeGlob({
+                ...input,
+                path: searchPath,
+            });
+        },
+    });
+}

package/dist/tools/builtin/grep.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Grep Tool - Search for patterns in files using regex
+ */
+import type { Tool } from '../types.js';
+/**
+ * Input parameters for grep tool
+ */
+export interface GrepInput {
+    /**
+     * Regular expression pattern to search for
+     */
+    pattern: string;
+    /**
+     * Path to file or directory to search in
+     */
+    path: string;
+    /**
+     * Case insensitive search (default: false)
+     */
+    ignoreCase?: boolean;
+    /**
+     * Include line numbers in output (default: true)
+     */
+    lineNumbers?: boolean;
+    /**
+     * Number of context lines before match (default: 0)
+     */
+    before?: number;
+    /**
+     * Number of context lines after match (default: 0)
+     */
+    after?: number;
+    /**
+     * Only return filenames with matches (default: false)
+     */
+    filesOnly?: boolean;
+    /**
+     * Include hidden files/directories (default: false)
+     */
+    includeHidden?: boolean;
+    /**
+     * File extensions to include (e.g., ['.ts', '.js'])
+     */
+    extensions?: string[];
+    /**
+     * Maximum number of matches to return (default: 100)
+     */
+    maxMatches?: number;
+    /**
+     * Search recursively in directories (default: true)
+     */
+    recursive?: boolean;
+}
+/**
+ * Grep tool definition
+ */
+export declare const grepTool: Tool<GrepInput>;
+/**
+ * Factory function to create a grep tool with custom options
+ *
+ * TODO: Future enhancements could include:
+ * - maxFileSize: Skip files larger than specified size
+ * - excludeDirs: Exclude directories by name (e.g., node_modules, .git)
+ */
+export declare function createGrepTool(options?: {
+    /**
+     * Base directory to resolve relative paths against
+     */
+    baseDir?: string;
+    /**
+     * Default file extensions to search
+     */
+    defaultExtensions?: string[];
+}): Tool<GrepInput>;