@trenchwork/erosolar 1.1.28 → 1.1.30

package/dist/capabilities/unifiedCodingCapability.js

@@ -1,788 +0,0 @@
-/**
- * UNIFIED CODING CAPABILITY
- *
- * A lean, consolidated capability module that provides all essential
- * tools for an AI coding assistant in a single, coherent interface.
- *
- * Consolidates: Filesystem, Edit, Bash, Search, Git, Web
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-import { buildDiffWithContext, formatDiffClaudeStyle } from '../tools/diffUtils.js';
-import { recordFileChange } from '../tools/fileChangeTracker.js';
-// ============================================================================
-// SCHEMA HELPERS
-// ============================================================================
-function stringProp(description, enumValues) {
-    const prop = {
-        type: 'string',
-        description,
-    };
-    if (enumValues) {
-        return { ...prop, enum: enumValues };
-    }
-    return prop;
-}
-function objectSchema(properties, required) {
-    return {
-        type: 'object',
-        properties,
-        required,
-    };
-}
-export class UnifiedCodingCapabilityModule {
-    id = 'unified-coding';
-    options;
-    constructor(options = {}) {
-        this.options = {
-            workingDir: options.workingDir ?? process.cwd(),
-            enableGit: options.enableGit ?? true,
-            enableWeb: options.enableWeb ?? true,
-            enableBash: options.enableBash ?? true,
-            maxFileSize: options.maxFileSize ?? 10 * 1024 * 1024, // 10MB
-            timeout: options.timeout ?? 30000, // 30s
-            provider: options.provider,
-            providerId: options.providerId,
-            modelId: options.modelId,
-            subagentType: options.subagentType,
-            allowedToolNames: options.allowedToolNames,
-            agentRegistry: options.agentRegistry,
-        };
-    }
-    async create(_context) {
-        return {
-            id: this.id,
-            description: 'Unified coding assistant tools',
-            toolSuite: this.buildToolSuite(),
-        };
-    }
-    buildToolSuite() {
-        const tools = [];
-        // === FILESYSTEM TOOLS ===
-        tools.push(this.createReadFileTool());
-        tools.push(this.createWriteFileTool());
-        tools.push(this.createListFilesTool());
-        tools.push(this.createFileExistsTool());
-        // === EDIT TOOLS ===
-        tools.push(this.createEditFileTool());
-        tools.push(this.createSearchReplaceTool());
-        // === SEARCH TOOLS ===
-        tools.push(this.createGrepTool());
-        tools.push(this.createGlobTool());
-        // === BASH TOOLS ===
-        if (this.options.enableBash) {
-            tools.push(this.createBashTool());
-        }
-        // === GIT TOOLS ===
-        if (this.options.enableGit) {
-            tools.push(this.createGitTool());
-        }
-        // === WEB TOOLS ===
-        if (this.options.enableWeb) {
-            tools.push(this.createWebFetchTool());
-        }
-        // === AGENT-SPAWN TOOLS ===
-        // Only the parent (no subagentType) gets these — sub-agents are
-        // explicitly forbidden from spawning further sub-agents.
-        if (this.options.provider && !this.options.subagentType) {
-            const agentTools = this.createAgentSpawnTools();
-            for (const t of agentTools)
-                tools.push(t);
-        }
-        // Apply tool filter for sub-agents.
-        let finalTools = tools;
-        if (this.options.allowedToolNames) {
-            finalTools = tools.filter((t) => this.options.allowedToolNames.has(t.name));
-        }
-        else if (this.options.subagentType) {
-            // Lazy-import the filter to avoid module init cycles.
-            // Pulling synchronously via require() is fine — this module is
-            // CommonJS-compatible at runtime.
-            const { filterToolsForType } = require('../core/agentRegistry.js');
-            const allowed = new Set(filterToolsForType(tools.map((t) => t.name), this.options.subagentType));
-            finalTools = tools.filter((t) => allowed.has(t.name));
-        }
-        return {
-            id: 'unified-coding-tools',
-            description: 'Unified coding assistant tools for file operations, editing, search, and execution',
-            tools: finalTools,
-        };
-    }
-    // ============================================================================
-    // FILESYSTEM TOOLS
-    // ============================================================================
-    createReadFileTool() {
-        return {
-            name: 'read_file',
-            description: 'Read the contents of a file. Returns the file content as a string.',
-            parameters: objectSchema({
-                path: stringProp('Absolute or relative path to the file'),
-                encoding: stringProp('File encoding (default: utf-8)'),
-            }, ['path']),
-            handler: async (args) => {
-                try {
-                    const filePath = this.resolvePath(args.path);
-                    const stat = fs.statSync(filePath);
-                    if (stat.size > this.options.maxFileSize) {
-                        return `Error: File too large (${stat.size} bytes). Max: ${this.options.maxFileSize} bytes`;
-                    }
-                    const content = fs.readFileSync(filePath, { encoding: args.encoding ?? 'utf-8' });
-                    return content;
-                }
-                catch (error) {
-                    return `Error reading file: ${error.message}`;
-                }
-            },
-        };
-    }
-    createWriteFileTool() {
-        return {
-            name: 'write_file',
-            description: 'Write content to a file. Creates the file if it does not exist.',
-            parameters: objectSchema({
-                path: stringProp('Absolute or relative path to the file'),
-                content: stringProp('Content to write to the file'),
-                createDirs: stringProp('Create parent directories if they do not exist (default: true)'),
-            }, ['path', 'content']),
-            handler: async (args) => {
-                try {
-                    const filePath = this.resolvePath(args.path);
-                    // Read old content if file exists (for diff)
-                    let oldContent = '';
-                    const fileExists = fs.existsSync(filePath);
-                    if (fileExists) {
-                        oldContent = fs.readFileSync(filePath, 'utf-8');
-                    }
-                    if (args.createDirs !== 'false') {
-                        const dir = path.dirname(filePath);
-                        if (!fs.existsSync(dir)) {
-                            fs.mkdirSync(dir, { recursive: true });
-                        }
-                    }
-                    // Record for revert before writing
-                    recordFileChange(filePath);
-                    fs.writeFileSync(filePath, args.content, 'utf-8');
-                    // Generate diff output
-                    const relativePath = path.relative(this.options.workingDir, filePath);
-                    const displayPath = relativePath && !relativePath.startsWith('..') ? relativePath : filePath;
-                    const diffResult = buildDiffWithContext(oldContent, args.content, 2);
-                    const { additions, removals } = diffResult;
-                    // Format diff with colors (limit to 10 lines)
-                    const MAX_DIFF_LINES = 10;
-                    const truncatedSegments = diffResult.segments.slice(0, MAX_DIFF_LINES);
-                    const diffLines = formatDiffClaudeStyle(truncatedSegments, true);
-                    const remainingChanges = diffResult.segments.length - MAX_DIFF_LINES;
-                    if (remainingChanges > 0) {
-                        diffLines.push(`      ... +${remainingChanges} more changes`);
-                    }
-                    const diffBlock = diffLines.length > 0 ? diffLines.join('\n') : '      (No visual diff)';
-                    // Build summary
-                    const action = fileExists ? 'Update' : 'Create';
-                    const additionText = additions === 1 ? '1 addition' : `${additions} additions`;
-                    const removalText = removals === 1 ? '1 removal' : `${removals} removals`;
-                    const summaryParts = [];
-                    if (additions > 0)
-                        summaryParts.push(additionText);
-                    if (removals > 0)
-                        summaryParts.push(removalText);
-                    const summaryText = summaryParts.length > 0 ? summaryParts.join(' and ') : 'no changes';
-                    return [
-                        `⏺ ${action}(${displayPath})`,
-                        `  ⎿  ${action}d ${displayPath} with ${summaryText}`,
-                        diffBlock,
-                    ].join('\n');
-                }
-                catch (error) {
-                    return `Error writing file: ${error.message}`;
-                }
-            },
-        };
-    }
-    createListFilesTool() {
-        return {
-            name: 'list_files',
-            description: 'List files in a directory. Optionally filter by pattern and recurse into subdirectories.',
-            parameters: objectSchema({
-                path: stringProp('Directory path to list'),
-                recursive: stringProp('Recurse into subdirectories (default: false)'),
-                pattern: stringProp('Glob pattern to filter files (e.g., "*.ts")'),
-            }, ['path']),
-            handler: async (args) => {
-                try {
-                    const dirPath = this.resolvePath(args.path);
-                    const files = this.listDirectory(dirPath, args.recursive === 'true', args.pattern);
-                    return files.join('\n');
-                }
-                catch (error) {
-                    return `Error listing files: ${error.message}`;
-                }
-            },
-        };
-    }
-    createFileExistsTool() {
-        return {
-            name: 'file_exists',
-            description: 'Check if a file or directory exists.',
-            parameters: objectSchema({
-                path: stringProp('Path to check'),
-            }, ['path']),
-            handler: async (args) => {
-                const filePath = this.resolvePath(args.path);
-                const exists = fs.existsSync(filePath);
-                if (exists) {
-                    const stat = fs.statSync(filePath);
-                    return `Exists: ${stat.isDirectory() ? 'directory' : 'file'}`;
-                }
-                return 'Does not exist';
-            },
-        };
-    }
-    // ============================================================================
-    // EDIT TOOLS
-    // ============================================================================
-    createEditFileTool() {
-        return {
-            name: 'edit_file',
-            description: 'Edit a file by replacing specific text. The oldText must match exactly.',
-            parameters: objectSchema({
-                path: stringProp('Path to the file to edit'),
-                oldText: stringProp('Exact text to find and replace'),
-                newText: stringProp('Text to replace with'),
-            }, ['path', 'oldText', 'newText']),
-            handler: async (args) => {
-                try {
-                    const filePath = this.resolvePath(args.path);
-                    const content = fs.readFileSync(filePath, 'utf-8');
-                    if (!content.includes(args.oldText)) {
-                        return `Error: Could not find the specified text in ${filePath}`;
-                    }
-                    const newContent = content.replace(args.oldText, args.newText);
-                    fs.writeFileSync(filePath, newContent, 'utf-8');
-                    return `Successfully edited ${filePath}`;
-                }
-                catch (error) {
-                    return `Error editing file: ${error.message}`;
-                }
-            },
-        };
-    }
-    createSearchReplaceTool() {
-        return {
-            name: 'search_replace',
-            description: 'Search and replace text in a file. Supports regex patterns.',
-            parameters: objectSchema({
-                path: stringProp('Path to the file'),
-                search: stringProp('Text or regex pattern to search for'),
-                replace: stringProp('Replacement text'),
-                regex: stringProp('Treat search as regex (default: false)'),
-                global: stringProp('Replace all occurrences (default: true)'),
-            }, ['path', 'search', 'replace']),
-            handler: async (args) => {
-                try {
-                    const filePath = this.resolvePath(args.path);
-                    const content = fs.readFileSync(filePath, 'utf-8');
-                    let pattern;
-                    if (args.regex === 'true') {
-                        const flags = args.global !== 'false' ? 'g' : '';
-                        pattern = new RegExp(args.search, flags);
-                    }
-                    else {
-                        pattern = args.global !== 'false'
-                            ? new RegExp(this.escapeRegex(args.search), 'g')
-                            : args.search;
-                    }
-                    const newContent = content.replace(pattern, args.replace);
-                    const matchCount = (content.match(pattern instanceof RegExp ? pattern : new RegExp(this.escapeRegex(args.search), 'g')) || []).length;
-                    fs.writeFileSync(filePath, newContent, 'utf-8');
-                    return `Replaced ${matchCount} occurrence(s) in ${filePath}`;
-                }
-                catch (error) {
-                    return `Error in search/replace: ${error.message}`;
-                }
-            },
-        };
-    }
-    // ============================================================================
-    // SEARCH TOOLS
-    // ============================================================================
-    createGrepTool() {
-        return {
-            name: 'grep',
-            description: 'Search for a pattern in files. Returns matching lines with file names and line numbers.',
-            parameters: objectSchema({
-                pattern: stringProp('Regex pattern to search for'),
-                path: stringProp('Directory or file to search in (default: working directory)'),
-                filePattern: stringProp('Filter files by glob pattern (e.g., "*.ts")'),
-                contextLines: stringProp('Number of context lines around matches (default: 0)'),
-            }, ['pattern']),
-            handler: async (args) => {
-                try {
-                    const searchPath = this.resolvePath(args.path ?? '.');
-                    const results = [];
-                    const files = fs.statSync(searchPath).isDirectory()
-                        ? this.listDirectory(searchPath, true, args.filePattern)
-                        : [searchPath];
-                    // Use regex without 'g' flag for test() to avoid lastIndex issues
-                    const regex = new RegExp(args.pattern, 'i');
-                    const contextLines = parseInt(args.contextLines ?? '0', 10) || 0;
-                    const matchedLineSet = new Set(); // Prevent duplicate context lines
-                    for (const file of files.slice(0, 100)) { // Limit to 100 files
-                        try {
-                            // Skip binary files by checking for null bytes
-                            const buffer = fs.readFileSync(file);
-                            if (buffer.includes(0))
-                                continue; // Binary file
-                            const content = buffer.toString('utf-8');
-                            // Skip very large files
-                            if (content.length > 1024 * 1024)
-                                continue; // > 1MB
-                            const lines = content.split('\n');
-                            const fileMatches = [];
-                            // First pass: find all matching line numbers
-                            for (let i = 0; i < lines.length; i++) {
-                                if (regex.test(lines[i])) {
-                                    fileMatches.push(i);
-                                }
-                            }
-                            // Second pass: output with context, avoiding duplicates
-                            for (const matchIdx of fileMatches) {
-                                const start = Math.max(0, matchIdx - contextLines);
-                                const end = Math.min(lines.length - 1, matchIdx + contextLines);
-                                for (let j = start; j <= end; j++) {
-                                    const lineKey = `${file}:${j}`;
-                                    if (!matchedLineSet.has(lineKey)) {
-                                        matchedLineSet.add(lineKey);
-                                        const prefix = j === matchIdx ? '>' : ' ';
-                                        results.push(`${file}:${j + 1}:${prefix} ${lines[j]}`);
-                                    }
-                                }
-                                if (contextLines > 0 && matchIdx < fileMatches[fileMatches.length - 1]) {
-                                    results.push('--');
-                                }
-                            }
-                        }
-                        catch {
-                            // Skip unreadable files
-                        }
-                        // Stop if we have enough results
-                        if (results.length > 500)
-                            break;
-                    }
-                    return results.length > 0
-                        ? results.slice(0, 500).join('\n')
-                        : 'No matches found';
-                }
-                catch (error) {
-                    return `Error in grep: ${error.message}`;
-                }
-            },
-        };
-    }
-    createGlobTool() {
-        return {
-            name: 'glob',
-            description: 'Find files matching a glob pattern.',
-            parameters: objectSchema({
-                pattern: stringProp('Glob pattern (e.g., "**/*.ts", "src/**/*.js")'),
-                path: stringProp('Base directory (default: working directory)'),
-            }, ['pattern']),
-            handler: async (args) => {
-                try {
-                    const basePath = this.resolvePath(args.path ?? '.');
-                    const files = this.listDirectory(basePath, true, args.pattern);
-                    return files.length > 0
-                        ? files.slice(0, 200).join('\n')
-                        : 'No files found matching pattern';
-                }
-                catch (error) {
-                    return `Error in glob: ${error.message}`;
-                }
-            },
-        };
-    }
-    // ============================================================================
-    // BASH TOOL
-    // ============================================================================
-    createBashTool() {
-        return {
-            name: 'bash',
-            description: 'Execute a bash command and return the output. Use for running builds, tests, git commands, etc.',
-            parameters: objectSchema({
-                command: stringProp('The command to execute'),
-                timeout: stringProp('Timeout in milliseconds (default: 30000)'),
-                cwd: stringProp('Working directory for the command'),
-            }, ['command']),
-            handler: async (args) => {
-                return new Promise((resolve) => {
-                    try {
-                        const timeout = parseInt(args.timeout ?? String(this.options.timeout), 10);
-                        const cwd = args.cwd ? this.resolvePath(args.cwd) : this.options.workingDir;
-                        const result = execSync(args.command, {
-                            cwd,
-                            timeout,
-                            encoding: 'utf-8',
-                            maxBuffer: 10 * 1024 * 1024,
-                            stdio: ['pipe', 'pipe', 'pipe'],
-                        });
-                        resolve(result.trim() || '(no output)');
-                    }
-                    catch (error) {
-                        const execError = error;
-                        const stdout = execError.stdout ?? '';
-                        const stderr = execError.stderr ?? '';
-                        resolve(`Error: ${execError.message}\nStdout: ${stdout}\nStderr: ${stderr}`);
-                    }
-                });
-            },
-        };
-    }
-    // ============================================================================
-    // GIT TOOL
-    // ============================================================================
-    createGitTool() {
-        return {
-            name: 'git',
-            description: 'Execute git operations. Supports: status, diff, log, add, commit, push, pull, branch, checkout, merge, stash',
-            parameters: objectSchema({
-                operation: stringProp('Git operation', ['status', 'diff', 'log', 'add', 'commit', 'push', 'pull', 'branch', 'checkout', 'merge', 'stash', 'reset', 'fetch']),
-                args: stringProp('Additional arguments for the git command'),
-            }, ['operation']),
-            handler: async (args) => {
-                try {
-                    const command = `git ${args.operation}${args.args ? ' ' + args.args : ''}`;
-                    const result = execSync(command, {
-                        cwd: this.options.workingDir,
-                        encoding: 'utf-8',
-                        timeout: this.options.timeout,
-                    });
-                    return result.trim() || '(no output)';
-                }
-                catch (error) {
-                    const execError = error;
-                    return `Git error: ${execError.stderr || execError.message}`;
-                }
-            },
-        };
-    }
-    // ============================================================================
-    // WEB TOOL
-    // ============================================================================
-    createWebFetchTool() {
-        return {
-            name: 'web_fetch',
-            description: 'Fetch content from a URL. Useful for downloading documentation or API responses.',
-            parameters: objectSchema({
-                url: stringProp('URL to fetch'),
-                method: stringProp('HTTP method (default: GET)'),
-                headers: stringProp('JSON string of headers'),
-            }, ['url']),
-            handler: async (args) => {
-                try {
-                    const headers = args.headers ? JSON.parse(args.headers) : {};
-                    const response = await fetch(args.url, {
-                        method: args.method ?? 'GET',
-                        headers,
-                    });
-                    if (!response.ok) {
-                        return `HTTP ${response.status}: ${response.statusText}`;
-                    }
-                    const contentType = response.headers.get('content-type') ?? '';
-                    if (contentType.includes('application/json')) {
-                        const json = await response.json();
-                        return JSON.stringify(json, null, 2);
-                    }
-                    const text = await response.text();
-                    return text.slice(0, 50000); // Limit response size
-                }
-                catch (error) {
-                    return `Fetch error: ${error.message}`;
-                }
-            },
-        };
-    }
-    // ============================================================================
-    // AGENT-SPAWN TOOLS — Claude-Code-style Agent + lifecycle tools
-    // ============================================================================
-    createAgentSpawnTools() {
-        const provider = this.options.provider;
-        const parentDir = this.options.workingDir;
-        const providerId = this.options.providerId;
-        const modelId = this.options.modelId;
-        // Defer registry creation so circular imports settle.
-        const { AgentRegistry, filterToolsForType } = require('../core/agentRegistry.js');
-        // Spawner closes over the LeanAgent class via lazy require.
-        const spawner = async (req, handle, deps) => {
-            const { LeanAgent } = require('../leanAgent.js');
-            const subAgent = new LeanAgent({
-                provider: provider,
-                workingDir: deps.workingDir,
-                providerId: providerId,
-                modelId: req.model ?? modelId,
-                systemPrompt: this.subagentSystemPrompt(handle.type, deps.workingDir),
-                capabilities: {
-                    ...this.options,
-                    subagentType: handle.type,
-                    // Don't pass parent's registry to a sub-agent.
-                    agentRegistry: undefined,
-                },
-            });
-            const response = await subAgent.chat(req.prompt, false);
-            handle.output = response.content;
-            handle.continuation = {
-                agentObject: subAgent,
-                spawnOptions: req,
-            };
-        };
-        const registry = this.options.agentRegistry ?? new AgentRegistry({ provider, workingDir: parentDir, providerId, modelId }, spawner);
-        // Cache for re-use within this capability instance.
-        this.options.agentRegistry = registry;
-        const tools = [];
-        // ---- Agent ---------------------------------------------------------------
-        tools.push({
-            name: 'Agent',
-            description: 'Spawn a sub-agent to handle a focused task. Pick subagent_type to ' +
-                'control the toolset:\n' +
-                '  - explore: read-only investigation (grep, glob, read_file, web_fetch). ' +
-                'Use for "where is X defined", "find files matching Y" — much cheaper than general.\n' +
-                '  - plan:    read-only design/planning. Returns a plan, no edits.\n' +
-                '  - general: full toolset (default). Use only when the task needs writes.\n\n' +
-                'Set run_in_background:true for long-running work; the tool returns immediately ' +
-                'with an agent id you can poll via agent_status / agent_output.\n\n' +
-                'Set isolation:"worktree" to run the sub-agent in a fresh git worktree so its ' +
-                'edits don\'t collide with yours; the worktree path + branch come back in the result ' +
-                'when changes were left behind.\n\n' +
-                'Run multiple Agent calls in one tool message to fan out in parallel.',
-            parameters: objectSchema({
-                description: stringProp('3-5 word task label'),
-                prompt: stringProp('Full instructions for the sub-agent'),
-                subagent_type: stringProp('"explore" | "plan" | "general" (default general)', ['general', 'explore', 'plan']),
-                model: stringProp('Optional model override, e.g. "deepseek-chat"'),
-                isolation: stringProp('"worktree" or "none" (default none)', ['worktree', 'none']),
-                run_in_background: stringProp('"true" to return immediately with an id'),
-            }, ['description', 'prompt']),
-            handler: async (args) => {
-                const description = String(args.description || '').slice(0, 80);
-                const prompt = String(args.prompt || '');
-                if (!prompt)
-                    return 'Error: prompt is required.';
-                const subagent_type = args.subagent_type || 'general';
-                if (!['general', 'explore', 'plan'].includes(subagent_type)) {
-                    return `Error: subagent_type must be general | explore | plan, got ${subagent_type}`;
-                }
-                const isolation = args.isolation === 'worktree' ? 'worktree' : 'none';
-                const runInBg = String(args.run_in_background ?? '').toLowerCase() === 'true';
-                const model = args.model ? String(args.model) : undefined;
-                const handle = registry.spawn({
-                    subagent_type: subagent_type,
-                    description: description || subagent_type,
-                    prompt,
-                    model,
-                    isolation,
-                    run_in_background: runInBg,
-                });
-                if (runInBg) {
-                    return formatHandle(handle, /* compact */ true) +
-                        '\n(Background. Use agent_status / agent_output / agent_send_message / agent_stop to interact.)';
-                }
-                await registry.wait(handle.id);
-                const finished = registry.get(handle.id) ?? handle;
-                return formatHandle(finished, false);
-            },
-        });
-        // ---- agent_list ----------------------------------------------------------
-        tools.push({
-            name: 'agent_list',
-            description: 'List all sub-agents launched in this session (running and finished).',
-            parameters: objectSchema({}, []),
-            handler: async () => {
-                const list = registry.list();
-                if (list.length === 0)
-                    return 'No sub-agents have been spawned in this session.';
-                return list.map((h) => formatHandle(h, true)).join('\n---\n');
-            },
-        });
-        // ---- agent_status --------------------------------------------------------
-        tools.push({
-            name: 'agent_status',
-            description: 'Get the status of a single sub-agent by id (without its full output).',
-            parameters: objectSchema({ id: stringProp('Agent id returned by Agent') }, ['id']),
-            handler: async (args) => {
-                const id = String(args.id || '');
-                const h = registry.get(id);
-                if (!h)
-                    return `No agent with id ${id}.`;
-                return formatHandle(h, true);
-            },
-        });
-        // ---- agent_output --------------------------------------------------------
-        tools.push({
-            name: 'agent_output',
-            description: 'Get the latest output from a sub-agent. If still running, returns whatever it has produced so far.',
-            parameters: objectSchema({ id: stringProp('Agent id') }, ['id']),
-            handler: async (args) => {
-                const id = String(args.id || '');
-                const h = registry.get(id);
-                if (!h)
-                    return `No agent with id ${id}.`;
-                return formatHandle(h, false);
-            },
-        });
-        // ---- agent_stop ----------------------------------------------------------
-        tools.push({
-            name: 'agent_stop',
-            description: 'Mark a running sub-agent as stopped. Best-effort: in-flight LLM calls will still complete.',
-            parameters: objectSchema({ id: stringProp('Agent id') }, ['id']),
-            handler: async (args) => {
-                const id = String(args.id || '');
-                const ok = registry.stop(id);
-                return ok ? `Agent ${id} marked stopped.` : `Could not stop ${id} (not found or already finished).`;
-            },
-        });
-        // ---- agent_send_message --------------------------------------------------
-        tools.push({
-            name: 'agent_send_message',
-            description: 'Send a follow-up message to a sub-agent that has finished its initial task. Continues the conversation in the same context.',
-            parameters: objectSchema({
-                id: stringProp('Agent id'),
-                message: stringProp('Follow-up message'),
-            }, ['id', 'message']),
-            handler: async (args) => {
-                const id = String(args.id || '');
-                const message = String(args.message || '');
-                if (!message)
-                    return 'Error: message is required.';
-                try {
-                    const reply = await registry.sendMessage(id, message);
-                    return reply;
-                }
-                catch (err) {
-                    return `Error: ${err.message}`;
-                }
-            },
-        });
-        // ---- parallel_agents (back-compat) ---------------------------------------
-        tools.push({
-            name: 'parallel_agents',
-            description: 'Backwards-compatible: spawn N sub-agents in parallel from a JSON array. ' +
-                'Prefer calling the `Agent` tool multiple times in one message instead — ' +
-                'that gives per-agent type / isolation / model control.',
-            parameters: objectSchema({ tasks: stringProp('JSON array of {id, description, prompt}') }, ['tasks']),
-            handler: async (args) => {
-                let specs;
-                try {
-                    specs = JSON.parse(String(args.tasks ?? ''));
-                }
-                catch {
-                    return 'Error: invalid JSON in tasks.';
-                }
-                if (!Array.isArray(specs) || specs.length === 0)
-                    return 'Error: tasks must be a non-empty array.';
-                if (specs.length > 5)
-                    return 'Error: max 5 parallel tasks.';
-                const handles = specs.map((s) => registry.spawn({
-                    subagent_type: 'general',
-                    description: s.description || s.id || 'task',
-                    prompt: s.prompt || '',
-                }));
-                await Promise.all(handles.map((h) => registry.wait(h.id)));
-                return handles
-                    .map((h) => formatHandle(registry.get(h.id) ?? h, false))
-                    .join('\n---\n');
-            },
-        });
-        return tools;
-    }
-    subagentSystemPrompt(type, cwd) {
-        const role = {
-            general: 'You are a focused sub-agent. Complete the task fully, report concisely. Make edits where needed.',
-            explore: 'You are a read-only investigation sub-agent. Use grep/glob/read_file to answer the question. Do NOT attempt to edit files; you have no write tools.',
-            plan: 'You are a planning sub-agent. Read what you need, then return a step-by-step plan. Do NOT edit files; the parent will execute.',
-        }[type];
-        return `${role}\n\nWorking directory: ${cwd}`;
-    }
-    // ============================================================================
-    // UTILITY METHODS
-    // ============================================================================
-    resolvePath(inputPath) {
-        if (path.isAbsolute(inputPath)) {
-            return inputPath;
-        }
-        return path.resolve(this.options.workingDir, inputPath);
-    }
-    listDirectory(dir, recursive, pattern) {
-        const results = [];
-        const regex = pattern ? this.globToRegex(pattern) : null;
-        const walk = (currentDir) => {
-            try {
-                const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-                for (const entry of entries) {
-                    const fullPath = path.join(currentDir, entry.name);
-                    // Skip hidden files and common ignore patterns
-                    if (entry.name.startsWith('.') || entry.name === 'node_modules') {
-                        continue;
-                    }
-                    if (entry.isDirectory()) {
-                        if (recursive) {
-                            walk(fullPath);
-                        }
-                    }
-                    else {
-                        if (!regex || regex.test(entry.name) || regex.test(fullPath)) {
-                            results.push(fullPath);
-                        }
-                    }
-                }
-            }
-            catch {
-                // Skip unreadable directories
-            }
-        };
-        walk(dir);
-        return results;
-    }
-    globToRegex(pattern) {
-        const escaped = pattern
-            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-        return new RegExp(escaped, 'i');
-    }
-    escapeRegex(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }
-}
-// ============================================================================
-// AGENT HANDLE FORMATTING
-// ============================================================================
-function formatHandle(h, compact) {
-    const elapsedMs = (h.endedAt ?? Date.now()) - h.startedAt;
-    const lines = [
-        `[${h.status.toUpperCase()}] ${h.id} · ${h.type} · ${h.description} · ${(elapsedMs / 1000).toFixed(1)}s`,
-    ];
-    if (h.worktreePath) {
-        lines.push(`  worktree: ${h.worktreePath} (branch ${h.worktreeBranch})`);
-    }
-    if (compact) {
-        return lines.join('\n');
-    }
-    if (h.error) {
-        lines.push(`  error: ${h.error}`);
-    }
-    if (h.output) {
-        lines.push('--- output ---');
-        lines.push(h.output);
-    }
-    else if (h.status === 'running') {
-        lines.push('  (no output yet — agent still running)');
-    }
-    return lines.join('\n');
-}
-// ============================================================================
-// FACTORY & CONVENIENCE EXPORTS
-// ============================================================================
-export function createUnifiedCodingCapability(options) {
-    return new UnifiedCodingCapabilityModule(options);
-}
-export default UnifiedCodingCapabilityModule;
-//# sourceMappingURL=unifiedCodingCapability.js.map