@specforge/mcp 2.6.0 → 3.0.0

package/dist/autopilot/agents/agent-runner.js

@@ -0,0 +1,731 @@
+/**
+ * Agent Runner
+ *
+ * Executes ticket implementation using AI Provider.
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { randomUUID } from 'crypto';
+import { AgentSelector } from './agent-selector.js';
+import { selectModelByComplexity, estimateModelCost } from './model-selector.js';
+import { parseSessionTokens } from '../../ai-provider/jsonl-parser.js';
+const execAsync = promisify(exec);
+/**
+ * Agent Runner
+ */
+export class AgentRunner {
+    aiProvider;
+    workingDirectory;
+    agentSelector;
+    autoCommit;
+    timeout;
+    constructor(options) {
+        this.aiProvider = options.aiProvider;
+        this.workingDirectory = options.workingDirectory;
+        this.agentSelector = options.agentSelector || new AgentSelector();
+        this.autoCommit = options.autoCommit ?? true;
+        this.timeout = options.timeout ?? 15 * 60 * 1000; // 15 minutes
+    }
+    /**
+     * Run implementation for a ticket
+     */
+    async run(context) {
+        const startTime = Date.now();
+        try {
+            // Select agent profile
+            const affectedFiles = AgentSelector.extractAffectedFiles({
+                ticket: context.ticket,
+                epic: context.epic,
+                specification: context.specification,
+            });
+            const profile = this.agentSelector.selectProfile({
+                ticket: context.ticket,
+                epic: context.epic,
+                specification: context.specification,
+                affectedFiles,
+            });
+            // Select model based on complexity (or use profile model if specified)
+            const model = profile.model ||
+                selectModelByComplexity(context.ticket.complexity);
+            // Build prompt
+            const prompt = this.buildPrompt(context, profile);
+            // Generate unique session ID for JSONL log linking
+            const sessionId = randomUUID();
+            // Run AI implementation
+            const aiResult = await this.aiProvider.run(prompt, {
+                workingDirectory: this.workingDirectory,
+                timeout: profile.timeoutMs || this.timeout,
+                model,
+                sessionId,
+            });
+            if (!aiResult.success) {
+                return {
+                    success: false,
+                    error: aiResult.error || 'AI implementation failed',
+                    durationMs: Date.now() - startTime,
+                    modelUsed: model,
+                    sessionId,
+                };
+            }
+            // Parse discoveries from AI output
+            const discoveries = this.parseDiscoveries(aiResult.output || '');
+            // Run validation commands
+            const validationResults = await this.runValidations(profile);
+            const allValidationsPassed = validationResults.every(r => r.success || !profile.validationCommands?.find(v => v.name === r.name)?.required);
+            // Extract file changes from output
+            const { created, modified, deleted } = this.extractFileChanges(aiResult.output);
+            if (!allValidationsPassed) {
+                const failedValidations = validationResults.filter(r => !r.success);
+                return {
+                    success: false,
+                    output: aiResult.output,
+                    error: `Validation failed: ${failedValidations.map(v => v.name).join(', ')}`,
+                    filesCreated: created,
+                    filesModified: modified,
+                    filesDeleted: deleted,
+                    testsPassed: false,
+                    durationMs: Date.now() - startTime,
+                    modelUsed: model,
+                    discoveries,
+                    sessionId,
+                };
+            }
+            // Auto-commit if enabled and capture SHA
+            let commitSha;
+            if (this.autoCommit) {
+                await this.commit(context.ticket);
+                commitSha = await this.getLastCommitSha();
+            }
+            // Estimate tokens as fallback
+            const estimatedTokens = {
+                inputTokens: Math.ceil(prompt.length / 4),
+                outputTokens: Math.ceil((aiResult.output?.length || 0) / 4),
+            };
+            // Try to read actual token usage from JSONL logs
+            let actualTokens = estimatedTokens;
+            let actualCost = estimateModelCost(model, estimatedTokens);
+            const parsedTokens = await parseSessionTokens(sessionId, this.workingDirectory);
+            if (parsedTokens) {
+                // Use actual tokens from JSONL (include cache tokens in input count)
+                actualTokens = {
+                    inputTokens: parsedTokens.inputTokens + parsedTokens.cacheCreationTokens + parsedTokens.cacheReadTokens,
+                    outputTokens: parsedTokens.outputTokens,
+                };
+                // Use actual cost if available from JSONL
+                if (parsedTokens.costUSD > 0) {
+                    actualCost = parsedTokens.costUSD;
+                }
+            }
+            return {
+                success: true,
+                output: aiResult.output,
+                filesCreated: created,
+                filesModified: modified,
+                filesDeleted: deleted,
+                testsPassed: allValidationsPassed,
+                tokensUsed: actualTokens,
+                costUsd: actualCost,
+                durationMs: Date.now() - startTime,
+                modelUsed: model,
+                commitSha,
+                discoveries,
+                sessionId,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                durationMs: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Build the implementation prompt with full ticket data
+     */
+    buildPrompt(context, profile) {
+        const { ticket, epic, specification } = context;
+        const extendedContext = context;
+        const parts = [];
+        // Header
+        parts.push(`# Implementation Task: ${ticket.title}\n`);
+        // Context
+        parts.push(`## Context`);
+        parts.push(`- **Specification**: ${specification.title}`);
+        parts.push(`- **Epic**: ${epic.title} (Epic ${epic.epicNumber})`);
+        parts.push(`- **Ticket**: ${ticket.title} (#${ticket.ticketNumber})`);
+        if (ticket.complexity) {
+            parts.push(`- **Complexity**: ${ticket.complexity}`);
+        }
+        if (ticket.priority) {
+            parts.push(`- **Priority**: ${ticket.priority}`);
+        }
+        parts.push('');
+        // Description
+        if (ticket.description) {
+            parts.push(`## Description`);
+            parts.push(ticket.description);
+            parts.push('');
+        }
+        // Acceptance Criteria
+        if (ticket.acceptanceCriteria && ticket.acceptanceCriteria.length > 0) {
+            parts.push(`## Acceptance Criteria`);
+            for (const criterion of ticket.acceptanceCriteria) {
+                if (typeof criterion === 'string') {
+                    parts.push(`- [ ] ${criterion}`);
+                }
+                else {
+                    parts.push(`- [ ] ${criterion.description}`);
+                }
+            }
+            parts.push('');
+        }
+        // Implementation Steps
+        if (ticket.implementation?.steps && ticket.implementation.steps.length > 0) {
+            parts.push(`## Implementation Steps`);
+            for (const step of ticket.implementation.steps) {
+                parts.push(`${step.order}. **${step.title}** (${step.action})`);
+                parts.push(`   ${step.detail}`);
+                if (step.targetFile) {
+                    parts.push(`   File: \`${step.targetFile}\``);
+                }
+                if (step.codeSnippet) {
+                    parts.push(`   \`\`\`\n   ${step.codeSnippet}\n   \`\`\``);
+                }
+            }
+            parts.push('');
+        }
+        // Code Examples (from implementation.codeExamples)
+        if (ticket.implementation?.codeExamples && ticket.implementation.codeExamples.length > 0) {
+            parts.push(`## Code Examples`);
+            for (const example of ticket.implementation.codeExamples) {
+                parts.push(`### ${example.name}`);
+                if (example.description) {
+                    parts.push(example.description);
+                }
+                parts.push(`\`\`\`${example.language}`);
+                parts.push(example.code);
+                parts.push('```');
+                parts.push('');
+            }
+        }
+        // Implementation Prerequisites
+        if (ticket.implementation?.prerequisites && ticket.implementation.prerequisites.length > 0) {
+            parts.push(`## Prerequisites`);
+            for (const prereq of ticket.implementation.prerequisites) {
+                parts.push(`- ${prereq}`);
+            }
+            parts.push('');
+        }
+        // Technical Details
+        if (ticket.technicalDetails) {
+            parts.push(`## Technical Details`);
+            if (ticket.technicalDetails.files?.create) {
+                parts.push(`### Files to Create`);
+                for (const file of ticket.technicalDetails.files.create) {
+                    parts.push(`- \`${file.path}\`: ${file.purpose}`);
+                }
+                parts.push('');
+            }
+            if (ticket.technicalDetails.files?.modify) {
+                parts.push(`### Files to Modify`);
+                for (const file of ticket.technicalDetails.files.modify) {
+                    parts.push(`- \`${file.path}\`: ${file.change}`);
+                }
+                parts.push('');
+            }
+            if (ticket.technicalDetails.files?.delete) {
+                parts.push(`### Files to Delete`);
+                for (const file of ticket.technicalDetails.files.delete) {
+                    parts.push(`- \`${file.path}\`: ${file.reason}`);
+                }
+                parts.push('');
+            }
+            if (ticket.technicalDetails.patterns) {
+                parts.push(`### Patterns to Follow`);
+                for (const [name, desc] of Object.entries(ticket.technicalDetails.patterns)) {
+                    parts.push(`- **${name}**: ${desc}`);
+                }
+                parts.push('');
+            }
+            // Required imports
+            if (ticket.technicalDetails.imports && ticket.technicalDetails.imports.length > 0) {
+                parts.push(`### Required Imports`);
+                for (const imp of ticket.technicalDetails.imports) {
+                    parts.push(`- \`${imp}\``);
+                }
+                parts.push('');
+            }
+            // API Endpoints
+            if (ticket.technicalDetails.endpoints && ticket.technicalDetails.endpoints.length > 0) {
+                parts.push(`### API Endpoints`);
+                for (const endpoint of ticket.technicalDetails.endpoints) {
+                    parts.push(`- **${endpoint.method}** \`${endpoint.path}\`: ${endpoint.description}`);
+                }
+                parts.push('');
+            }
+            // Database Operations
+            if (ticket.technicalDetails.database && ticket.technicalDetails.database.length > 0) {
+                parts.push(`### Database Operations`);
+                for (const op of ticket.technicalDetails.database) {
+                    parts.push(`- **${op.type}** on \`${op.table}\`: ${op.description}`);
+                }
+                parts.push('');
+            }
+            // Environment Variables
+            if (ticket.technicalDetails.envVars && ticket.technicalDetails.envVars.length > 0) {
+                parts.push(`### Environment Variables`);
+                for (const env of ticket.technicalDetails.envVars) {
+                    const required = env.required ? ' (required)' : ' (optional)';
+                    parts.push(`- \`${env.name}\`${required}: ${env.description}`);
+                }
+                parts.push('');
+            }
+            // External Services
+            if (ticket.technicalDetails.externalServices && ticket.technicalDetails.externalServices.length > 0) {
+                parts.push(`### External Services`);
+                for (const service of ticket.technicalDetails.externalServices) {
+                    parts.push(`- **${service.name}**: ${service.purpose}`);
+                }
+                parts.push('');
+            }
+        }
+        // Structured Notes (from ticket.notes when object)
+        if (ticket.notes) {
+            const notesObj = typeof ticket.notes === 'string'
+                ? this.tryParseStructuredNotes(ticket.notes)
+                : ticket.notes;
+            if (notesObj) {
+                if (notesObj.warnings && notesObj.warnings.length > 0) {
+                    parts.push(`## Warnings`);
+                    for (const warning of notesObj.warnings) {
+                        parts.push(`- ⚠️ ${warning}`);
+                    }
+                    parts.push('');
+                }
+                if (notesObj.bestPractices && notesObj.bestPractices.length > 0) {
+                    parts.push(`## Best Practices`);
+                    for (const practice of notesObj.bestPractices) {
+                        parts.push(`- ${practice}`);
+                    }
+                    parts.push('');
+                }
+                if (notesObj.alternatives && notesObj.alternatives.length > 0) {
+                    parts.push(`## Alternatives Considered`);
+                    for (const alt of notesObj.alternatives) {
+                        parts.push(`- ${alt}`);
+                    }
+                    parts.push('');
+                }
+                if (notesObj.references && notesObj.references.length > 0) {
+                    parts.push(`## References`);
+                    for (const ref of notesObj.references) {
+                        parts.push(`- ${ref}`);
+                    }
+                    parts.push('');
+                }
+                if (notesObj.limitations && notesObj.limitations.length > 0) {
+                    parts.push(`## Limitations`);
+                    for (const limitation of notesObj.limitations) {
+                        parts.push(`- ${limitation}`);
+                    }
+                    parts.push('');
+                }
+            }
+            else if (typeof ticket.notes === 'string') {
+                // Plain string notes
+                parts.push(`## Notes`);
+                parts.push(ticket.notes);
+                parts.push('');
+            }
+        }
+        // Epic-Level Context
+        if (epic.sharedPatterns || epic.additionalImports || epic.commonFiles) {
+            parts.push(`## Epic Context`);
+            if (epic.sharedPatterns) {
+                parts.push(`### Shared Patterns for ${epic.title}`);
+                const patterns = epic.sharedPatterns;
+                for (const [key, value] of Object.entries(patterns)) {
+                    if (value)
+                        parts.push(`- **${key}**: ${value}`);
+                }
+                parts.push('');
+            }
+            if (epic.additionalImports && epic.additionalImports.length > 0) {
+                parts.push(`### Epic Imports`);
+                for (const imp of epic.additionalImports) {
+                    parts.push(`- \`${imp}\``);
+                }
+                parts.push('');
+            }
+            if (epic.commonFiles) {
+                parts.push(`### Common Files`);
+                const files = epic.commonFiles;
+                for (const [key, path] of Object.entries(files)) {
+                    if (path)
+                        parts.push(`- **${key}**: \`${path}\``);
+                }
+                parts.push('');
+            }
+        }
+        // Specification Architecture
+        if (specification.architecture || specification.fileStructure || specification.goals) {
+            parts.push(`## Specification Architecture`);
+            if (specification.architecture) {
+                parts.push(`### Architecture Overview`);
+                parts.push(specification.architecture);
+                parts.push('');
+            }
+            if (specification.fileStructure) {
+                parts.push(`### File Structure`);
+                parts.push('```');
+                parts.push(specification.fileStructure);
+                parts.push('```');
+                parts.push('');
+            }
+            if (specification.goals && specification.goals.length > 0) {
+                parts.push(`### Goals`);
+                for (const goal of specification.goals) {
+                    parts.push(`- ${goal}`);
+                }
+                parts.push('');
+            }
+            if (specification.requirements && specification.requirements.length > 0) {
+                parts.push(`### Requirements`);
+                for (const req of specification.requirements) {
+                    parts.push(`- ${req}`);
+                }
+                parts.push('');
+            }
+            if (specification.constraints && specification.constraints.length > 0) {
+                parts.push(`### Constraints`);
+                for (const constraint of specification.constraints) {
+                    parts.push(`- ${constraint}`);
+                }
+                parts.push('');
+            }
+        }
+        // Code Standards from Specification
+        if (specification.codeStandards) {
+            parts.push(`## Code Standards`);
+            const standards = specification.codeStandards;
+            if (standards.language)
+                parts.push(`- **Language**: ${standards.language}`);
+            if (standards.asyncPattern)
+                parts.push(`- **Async Pattern**: ${standards.asyncPattern}`);
+            if (standards.errorHandling)
+                parts.push(`- **Error Handling**: ${standards.errorHandling}`);
+            if (standards.testing)
+                parts.push(`- **Testing**: ${standards.testing}`);
+            if (standards.documentation)
+                parts.push(`- **Documentation**: ${standards.documentation}`);
+            if (standards.stateManagement)
+                parts.push(`- **State Management**: ${standards.stateManagement}`);
+            if (standards.apiPattern)
+                parts.push(`- **API Pattern**: ${standards.apiPattern}`);
+            if (standards.logging)
+                parts.push(`- **Logging**: ${standards.logging}`);
+            if (standards.validation)
+                parts.push(`- **Validation**: ${standards.validation}`);
+            parts.push('');
+        }
+        // Previous Attempts (from context.previousAttempts)
+        if (extendedContext.previousAttempts && extendedContext.previousAttempts.length > 0) {
+            parts.push(`## Previous Attempts`);
+            parts.push(`The following approaches were tried before and failed:`);
+            for (const attempt of extendedContext.previousAttempts) {
+                parts.push(`- **${attempt.approach}**: ${attempt.reason}`);
+            }
+            parts.push('');
+        }
+        // Related Discoveries (from context.relatedDiscoveries)
+        if (extendedContext.relatedDiscoveries && extendedContext.relatedDiscoveries.length > 0) {
+            parts.push(`## Related Discoveries`);
+            parts.push(`Be aware of these known issues/blockers:`);
+            for (const discovery of extendedContext.relatedDiscoveries) {
+                const severity = discovery.severity ? ` [${discovery.severity}]` : '';
+                parts.push(`- **${discovery.type}${severity}**: ${discovery.title}`);
+                if (discovery.description) {
+                    parts.push(`  ${discovery.description}`);
+                }
+            }
+            parts.push('');
+        }
+        // Dependencies
+        if (context.dependencies.blockedBy.length > 0) {
+            parts.push(`## Dependencies (Already Completed)`);
+            for (const dep of context.dependencies.blockedBy) {
+                parts.push(`- ${dep.title} (${dep.status})`);
+            }
+            parts.push('');
+        }
+        // Profile-specific additions
+        if (profile.systemPromptAdditions) {
+            parts.push(`## Additional Guidelines`);
+            parts.push(profile.systemPromptAdditions.trim());
+            parts.push('');
+        }
+        // Discovery Reporting Instructions
+        parts.push(`## Reporting Discoveries`);
+        parts.push(`If you encounter issues during implementation, report them using these markers:`);
+        parts.push('');
+        parts.push('```');
+        parts.push('DISCOVERY: [type] [severity]');
+        parts.push('Title: <title>');
+        parts.push('Description: <description>');
+        parts.push('```');
+        parts.push('');
+        parts.push('Types: bug, technical_debt, new_requirement, question, blocker, improvement');
+        parts.push('Severity: low, medium, high, critical');
+        parts.push('');
+        parts.push('Example:');
+        parts.push('```');
+        parts.push('DISCOVERY: technical_debt medium');
+        parts.push('Title: Legacy API needs migration');
+        parts.push('Description: The current API uses deprecated endpoints that should be updated.');
+        parts.push('```');
+        parts.push('');
+        // Instructions
+        parts.push(`## Instructions`);
+        parts.push(`Please implement this ticket following the steps and requirements above.`);
+        parts.push(`Make sure to:`);
+        parts.push(`1. Follow the existing code patterns in the codebase`);
+        parts.push(`2. Use proper TypeScript types`);
+        parts.push(`3. Handle errors appropriately`);
+        parts.push(`4. Write clean, maintainable code`);
+        parts.push(`5. Report any discoveries using the markers above`);
+        parts.push('');
+        return parts.join('\n');
+    }
+    /**
+     * Try to parse structured notes from a string
+     */
+    tryParseStructuredNotes(notes) {
+        try {
+            const parsed = JSON.parse(notes);
+            if (typeof parsed === 'object' && parsed !== null) {
+                return parsed;
+            }
+        }
+        catch {
+            // Not JSON, return null
+        }
+        return null;
+    }
+    /**
+     * Run validation commands
+     */
+    async runValidations(profile) {
+        if (!profile.validationCommands || profile.validationCommands.length === 0) {
+            return [];
+        }
+        const results = [];
+        for (const validation of profile.validationCommands) {
+            const result = await this.runValidationCommand(validation);
+            results.push(result);
+            // Stop on required validation failure
+            if (!result.success && validation.required) {
+                break;
+            }
+        }
+        return results;
+    }
+    /**
+     * Run a single validation command
+     */
+    async runValidationCommand(validation) {
+        const startTime = Date.now();
+        const cwd = validation.cwd
+            ? `${this.workingDirectory}/${validation.cwd}`
+            : this.workingDirectory;
+        try {
+            const { stdout, stderr } = await execAsync(validation.command, {
+                cwd,
+                timeout: validation.timeoutMs || 60000,
+            });
+            return {
+                command: validation.command,
+                name: validation.name,
+                success: true,
+                output: stdout + stderr,
+                durationMs: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            const execError = error;
+            return {
+                command: validation.command,
+                name: validation.name,
+                success: false,
+                output: execError.stdout,
+                error: execError.stderr || execError.message,
+                durationMs: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Commit changes for a ticket
+     */
+    async commit(ticket) {
+        try {
+            // Stage all changes
+            await execAsync('git add -A', { cwd: this.workingDirectory });
+            // Create commit
+            const message = `feat: ${ticket.title}\n\nTicket: #${ticket.ticketNumber}\n\nCo-Authored-By: SpecForge Autopilot <autopilot@specforge.dev>`;
+            await execAsync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
+                cwd: this.workingDirectory,
+            });
+        }
+        catch (error) {
+            // Ignore if nothing to commit
+            const execError = error;
+            if (!execError.stderr?.includes('nothing to commit')) {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Parse discoveries from AI output using explicit markers
+     */
+    parseDiscoveries(output) {
+        if (!output)
+            return [];
+        const discoveries = [];
+        // Parse discoveries - note: using [\s\S] instead of 's' flag for ES compatibility
+        const regex = /DISCOVERY:\s*(\w+)\s+(\w+)\s*\nTitle:\s*([^\n]+)\nDescription:\s*([\s\S]+?)(?=\n\nDISCOVERY:|\n\n\n|$)/gi;
+        let match;
+        while ((match = regex.exec(output)) !== null) {
+            const [, typeStr, severityStr, title, description] = match;
+            const type = this.parseDiscoveryType(typeStr.trim().toLowerCase());
+            const severity = this.parseDiscoverySeverity(severityStr.trim().toLowerCase());
+            if (type && severity) {
+                discoveries.push({
+                    type,
+                    severity,
+                    title: title.trim(),
+                    description: description.trim(),
+                });
+            }
+        }
+        return discoveries;
+    }
+    /**
+     * Parse and validate discovery type
+     */
+    parseDiscoveryType(type) {
+        const validTypes = [
+            'bug', 'technical_debt', 'new_requirement', 'question', 'blocker', 'improvement'
+        ];
+        return validTypes.includes(type) ? type : null;
+    }
+    /**
+     * Parse and validate discovery severity
+     */
+    parseDiscoverySeverity(severity) {
+        const validSeverities = ['low', 'medium', 'high', 'critical'];
+        return validSeverities.includes(severity) ? severity : null;
+    }
+    /**
+     * Extract file changes (created, modified, deleted) from AI output
+     */
+    extractFileChanges(output) {
+        if (!output)
+            return { created: [], modified: [], deleted: [] };
+        const created = [];
+        const modified = [];
+        const deleted = [];
+        // Patterns for created files
+        const createPatterns = [
+            /Created?\s+(?:file\s+)?[`']?([^\s`']+\.\w+)[`']?/gi,
+            /New file[:\s]+[`']?([^\s`']+\.\w+)[`']?/gi,
+            /Added\s+[`']?([^\s`']+\.\w+)[`']?/gi,
+        ];
+        // Patterns for modified files
+        const modifyPatterns = [
+            /Modified?\s+(?:file\s+)?[`']?([^\s`']+\.\w+)[`']?/gi,
+            /Updated?\s+(?:file\s+)?[`']?([^\s`']+\.\w+)[`']?/gi,
+            /Edited?\s+(?:file\s+)?[`']?([^\s`']+\.\w+)[`']?/gi,
+            /Changed?\s+(?:file\s+)?[`']?([^\s`']+\.\w+)[`']?/gi,
+        ];
+        // Patterns for deleted files
+        const deletePatterns = [
+            /Deleted?\s+(?:file\s+)?[`']?([^\s`']+\.\w+)[`']?/gi,
+            /Removed?\s+(?:file\s+)?[`']?([^\s`']+\.\w+)[`']?/gi,
+        ];
+        for (const pattern of createPatterns) {
+            let match;
+            while ((match = pattern.exec(output)) !== null) {
+                created.push(match[1]);
+            }
+        }
+        for (const pattern of modifyPatterns) {
+            let match;
+            while ((match = pattern.exec(output)) !== null) {
+                modified.push(match[1]);
+            }
+        }
+        for (const pattern of deletePatterns) {
+            let match;
+            while ((match = pattern.exec(output)) !== null) {
+                deleted.push(match[1]);
+            }
+        }
+        return {
+            created: [...new Set(created)],
+            modified: [...new Set(modified)],
+            deleted: [...new Set(deleted)],
+        };
+    }
+    /**
+     * Get the SHA of the last commit
+     */
+    async getLastCommitSha() {
+        try {
+            const { stdout } = await execAsync('git rev-parse HEAD', {
+                cwd: this.workingDirectory,
+            });
+            return stdout.trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Extract modified files from AI output (legacy method for backwards compatibility)
+     */
+    extractModifiedFiles(output) {
+        const { created, modified, deleted } = this.extractFileChanges(output);
+        return [...new Set([...created, ...modified, ...deleted])];
+    }
+    /**
+     * Get AI provider
+     */
+    getAIProvider() {
+        return this.aiProvider;
+    }
+    /**
+     * Get agent selector
+     */
+    getAgentSelector() {
+        return this.agentSelector;
+    }
+    /**
+     * Update working directory
+     */
+    setWorkingDirectory(dir) {
+        this.workingDirectory = dir;
+    }
+    /**
+     * Get working directory
+     */
+    getWorkingDirectory() {
+        return this.workingDirectory;
+    }
+}
+/**
+ * Create an agent runner
+ */
+export function createAgentRunner(options) {
+    return new AgentRunner(options);
+}
+//# sourceMappingURL=agent-runner.js.map