swarm-orchestrator 7.0.0-alpha.0

package/dist/src/repair-agent.js

@@ -0,0 +1,396 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepairAgent = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const session_executor_1 = __importDefault(require("./session-executor"));
+const verifier_engine_1 = __importDefault(require("./verifier-engine"));
+const test_command_discovery_1 = require("./test-command-discovery");
+const logger_1 = require("./logger");
+const defaults_1 = require("./defaults");
+const logger = (0, logger_1.getLogger)('repair-agent');
+// Approximate tokens per character (GPT-family average: ~4 chars per token).
+const CHARS_PER_TOKEN = 4;
+/**
+ * RepairAgent - spawns a dedicated Copilot CLI session with failure context
+ * to fix issues detected by the verifier, then re-verifies.
+ *
+ * Retry loop: up to maxRetries attempts. Each attempt receives the prior
+ * transcript and verification report so the agent can see what went wrong.
+ */
+class RepairAgent {
+    workingDir;
+    maxRetries;
+    constructor(workingDir, maxRetries) {
+        this.workingDir = workingDir;
+        this.maxRetries = maxRetries ?? 3;
+    }
+    /**
+     * Build a repair prompt that includes the failure context so the agent
+     * knows exactly what to fix.
+     */
+    buildRepairPrompt(context) {
+        const sections = [];
+        sections.push('=== REPAIR AGENT - Self-Repair Session ===');
+        sections.push('');
+        sections.push(`Step ${context.stepNumber} (${context.agentName}) failed verification.`);
+        sections.push(`Repair attempt ${context.retryCount} of ${this.maxRetries}.`);
+        sections.push('');
+        sections.push('--- ORIGINAL TASK ---');
+        sections.push(context.originalTask);
+        sections.push('');
+        // Include failed checks so the repair agent knows exactly what to fix
+        if (context.failedChecks.length > 0) {
+            sections.push('--- FAILED VERIFICATION CHECKS ---');
+            context.failedChecks.forEach((check, i) => {
+                sections.push(`  ${i + 1}. ${check}`);
+            });
+            sections.push('');
+        }
+        if (context.rootCause) {
+            sections.push('--- ROOT CAUSE ---');
+            sections.push(context.rootCause);
+            sections.push('');
+        }
+        // Include the verification report if it exists on disk
+        if (context.verificationReportPath && fs.existsSync(context.verificationReportPath)) {
+            const report = fs.readFileSync(context.verificationReportPath, 'utf8');
+            // Cap at 4000 chars to stay within prompt budget
+            const trimmed = report.length > defaults_1.DEFAULT_REPAIR_REPORT_CHARS
+                ? report.slice(0, defaults_1.DEFAULT_REPAIR_REPORT_CHARS) + '\n... (truncated)'
+                : report;
+            sections.push('--- VERIFICATION REPORT ---');
+            sections.push(trimmed);
+            sections.push('');
+        }
+        // Include the original transcript so the repair agent can see what the
+        // previous agent actually did (and did wrong).
+        if (context.transcriptPath && fs.existsSync(context.transcriptPath)) {
+            const transcript = fs.readFileSync(context.transcriptPath, 'utf8');
+            // Cap at 6000 chars
+            const trimmed = transcript.length > defaults_1.DEFAULT_REPAIR_TRANSCRIPT_CHARS
+                ? transcript.slice(0, defaults_1.DEFAULT_REPAIR_TRANSCRIPT_CHARS) + '\n... (truncated)'
+                : transcript;
+            sections.push('--- PRIOR SESSION TRANSCRIPT ---');
+            sections.push(trimmed);
+            sections.push('');
+        }
+        // Include git diff on the branch so the agent sees current state
+        const diff = this.getGitDiff(context.branchName);
+        if (diff) {
+            const trimmed = diff.length > defaults_1.DEFAULT_REPAIR_REPORT_CHARS
+                ? diff.slice(0, defaults_1.DEFAULT_REPAIR_REPORT_CHARS) + '\n... (truncated)'
+                : diff;
+            sections.push('--- GIT DIFF ON BRANCH ---');
+            sections.push(trimmed);
+            sections.push('');
+        }
+        // Outcome evidence: structured failure context from verifier engine
+        if (context.failureContext) {
+            sections.push('--- OUTCOME EVIDENCE ---');
+            sections.push(context.failureContext);
+            sections.push('');
+        }
+        // Discover the target project's full test gate before the repair
+        // instructions so the agent commits only after running the real script.
+        const testDiscovery = (0, test_command_discovery_1.discoverTestCommand)(this.workingDir);
+        if (testDiscovery.warning && !(0, logger_1.isPrettyMode)()) {
+            logger.warn(`test command discovery: ${testDiscovery.warning}`);
+        }
+        sections.push((0, test_command_discovery_1.renderVerifyCommandSection)(testDiscovery));
+        sections.push('--- REPAIR INSTRUCTIONS ---');
+        // classify failure and inject targeted strategy (Upgrade 9)
+        const failureClass = this.classifyFailure(context.failedChecks, context.rootCause);
+        const strategy = this.getRepairStrategy(failureClass);
+        sections.push(`--- FAILURE CLASSIFICATION: ${failureClass} ---`);
+        sections.push(strategy);
+        sections.push('');
+        // inject focused evidence for specific failure types
+        if (failureClass === 'test-failure') {
+            const testChecks = context.failedChecks.filter(c => c.startsWith('[test]'));
+            if (testChecks.length > 0) {
+                sections.push('Failing test checks:');
+                testChecks.forEach(t => sections.push(`  - ${t}`));
+                sections.push('');
+            }
+        }
+        else if (failureClass === 'build-failure') {
+            const buildChecks = context.failedChecks.filter(c => c.startsWith('[build]'));
+            if (buildChecks.length > 0) {
+                sections.push('Build errors:');
+                buildChecks.forEach(b => sections.push(`  - ${b}`));
+                sections.push('');
+            }
+        }
+        // Signal urgency when this is the final allowed attempt
+        if (context.retryCount >= this.maxRetries) {
+            sections.push('This is the final attempt. Prioritize getting a working result over completeness.');
+            sections.push('');
+        }
+        sections.push('4. Commit your fixes with a clear message starting with "repair:".');
+        sections.push('5. Do not claim work is done without evidence in the transcript.');
+        sections.push('');
+        return sections.join('\n');
+    }
+    /**
+     * Estimate token cost from a transcript string.
+     * Uses a simple character-to-token ratio (approximately 4 chars per token
+     * for English text in GPT-family models).
+     */
+    estimateTokenCost(text) {
+        if (!text)
+            return 0;
+        return Math.ceil(text.length / CHARS_PER_TOKEN);
+    }
+    /**
+     * Run the repair loop: up to maxRetries attempts.
+     * Each attempt spawns a Copilot CLI session with the failure context,
+     * then re-verifies. Stops on first successful verification.
+     *
+     * Returns a RepairResult summarizing all attempts.
+     */
+    async attemptRepair(context, sessionOptions, verificationRequirements) {
+        const attemptDetails = [];
+        let totalTokens = 0;
+        const overallStart = Date.now();
+        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+            const attemptStart = Date.now();
+            // Update retry count in context for prompt generation
+            const repairContext = { ...context, retryCount: attempt };
+            const prompt = this.buildRepairPrompt(repairContext);
+            totalTokens += this.estimateTokenCost(prompt);
+            // Set up transcript path for this repair attempt
+            const repairTranscript = this.getRepairTranscriptPath(context, attempt);
+            const repairDir = path.dirname(repairTranscript);
+            if (!fs.existsSync(repairDir)) {
+                fs.mkdirSync(repairDir, { recursive: true });
+            }
+            const opts = {
+                ...sessionOptions,
+                shareToFile: repairTranscript,
+                logPrefix: `[REPAIR:${context.agentName}:${context.stepNumber}:attempt-${attempt}]`
+            };
+            let sessionResult;
+            try {
+                // Create session executor for the working directory (may be a worktree)
+                const executor = new session_executor_1.default(this.workingDir);
+                sessionResult = await executor.executeSession(prompt, opts);
+                // Estimate tokens from output
+                if (sessionResult.output) {
+                    totalTokens += this.estimateTokenCost(sessionResult.output);
+                }
+                if (!sessionResult.success) {
+                    attemptDetails.push({
+                        attempt,
+                        durationMs: Date.now() - attemptStart,
+                        sessionSuccess: false,
+                        verificationPassed: false,
+                        estimatedTokens: this.estimateTokenCost(prompt) + this.estimateTokenCost(sessionResult.output || ''),
+                        error: sessionResult.error || 'Session exited with non-zero code'
+                    });
+                    continue;
+                }
+                // Re-verify
+                const transcriptToVerify = fs.existsSync(repairTranscript)
+                    ? repairTranscript
+                    : context.transcriptPath;
+                const verifier = new verifier_engine_1.default(this.workingDir);
+                const verificationResult = await verifier.verifyStep(context.stepNumber, context.agentName, transcriptToVerify, verificationRequirements);
+                const verificationPassed = verificationResult.passed;
+                attemptDetails.push({
+                    attempt,
+                    durationMs: Date.now() - attemptStart,
+                    sessionSuccess: true,
+                    verificationPassed,
+                    estimatedTokens: this.estimateTokenCost(prompt) + this.estimateTokenCost(sessionResult.output || '')
+                });
+                if (verificationPassed) {
+                    return {
+                        success: true,
+                        attempts: attempt,
+                        verificationPassed: true,
+                        transcriptPath: repairTranscript,
+                        estimatedTokenCost: totalTokens,
+                        totalDurationMs: Date.now() - overallStart,
+                        attemptDetails
+                    };
+                }
+                // Update the context with the new transcript and report for next attempt
+                context = {
+                    ...context,
+                    transcriptPath: repairTranscript,
+                    failedChecks: this.extractFailedChecks(verificationResult)
+                };
+            }
+            catch (error) {
+                const err = error;
+                attemptDetails.push({
+                    attempt,
+                    durationMs: Date.now() - attemptStart,
+                    sessionSuccess: false,
+                    verificationPassed: false,
+                    estimatedTokens: this.estimateTokenCost(prompt),
+                    error: err.message
+                });
+            }
+        }
+        // All retries exhausted
+        return {
+            success: false,
+            attempts: this.maxRetries,
+            verificationPassed: false,
+            transcriptPath: attemptDetails.length > 0
+                ? this.getRepairTranscriptPath(context, attemptDetails.length)
+                : null,
+            estimatedTokenCost: totalTokens,
+            totalDurationMs: Date.now() - overallStart,
+            attemptDetails,
+            error: `Repair failed after ${this.maxRetries} attempt(s)`
+        };
+    }
+    /**
+     * Classify failure type from tagged check strings and root cause.
+     * Uses frequency count on [type] prefixes from extractFailedChecks output.
+     */
+    classifyFailure(failedChecks, rootCause) {
+        const lower = [...failedChecks.map(c => c.toLowerCase()), rootCause.toLowerCase()].join(' ');
+        // priority: timeout > dependency > missing artifact > majority tag
+        if (/timeout|timed out/.test(lower))
+            return 'timeout';
+        if (/\bpackage\b|\bdependency\b|\bmodule not found\b/.test(lower))
+            return 'dependency-error';
+        if (/not found|not created|missing|\[missing-files\]|\[no-changes\]/.test(lower))
+            return 'missing-artifact';
+        // count tagged prefixes
+        let buildCount = 0, testCount = 0;
+        for (const check of failedChecks) {
+            if (check.startsWith('[build]'))
+                buildCount++;
+            else if (check.startsWith('[test]'))
+                testCount++;
+        }
+        if (buildCount > 0 && buildCount >= testCount)
+            return 'build-failure';
+        if (testCount > 0)
+            return 'test-failure';
+        return 'general';
+    }
+    /**
+     * Return targeted repair instructions for the given failure class.
+     * Replaces the generic one-size-fits-all instructions.
+     */
+    getRepairStrategy(failureClass) {
+        switch (failureClass) {
+            case 'build-failure':
+                return 'Focus on the compiler/bundler errors below. Fix the specific file and line mentioned. Do not change unrelated code.';
+            case 'test-failure':
+                return 'The failing test names and assertions are listed below. Fix the implementation to make these tests pass. Do not modify the tests.';
+            case 'missing-artifact':
+                return 'The following expected files were not created. Create them now.';
+            case 'dependency-error':
+                return 'Install or fix the missing dependencies listed below.';
+            case 'timeout':
+                return 'The previous session timed out. Simplify the task: focus on the minimum viable deliverable, skip optional steps.';
+            case 'general':
+                return '1. Read the failed checks and root cause above carefully.\n2. Fix the specific issues identified. Do not redo unrelated work.\n3. Run tests if the task requires tests.';
+        }
+    }
+    /**
+     * Extract human-readable failed check descriptions from a VerificationResult.
+     */
+    extractFailedChecks(result) {
+        const checks = [];
+        for (const check of result.checks) {
+            if (!check.passed) {
+                const label = this.formatCheckLabel(check);
+                checks.push(label);
+            }
+        }
+        if (result.unverifiedClaims.length > 0) {
+            checks.push(`Unverified claims: ${result.unverifiedClaims.join('; ')}`);
+        }
+        return checks;
+    }
+    /**
+     * Format a single failed check into a tagged string.
+     * Outcome-based check types get richer detail than transcript-parsed ones.
+     */
+    formatCheckLabel(check) {
+        const reason = check.reason ? ` - ${check.reason}` : '';
+        switch (check.type) {
+            case 'build_exec':
+                return `[build] ${check.description}${reason}`;
+            case 'test_exec':
+                return `[test] ${check.description}${reason}`;
+            case 'file_existence':
+                return `[missing-files] ${check.description}${reason}`;
+            case 'git_diff':
+                return `[no-changes] ${check.description}${reason}`;
+            default:
+                return `[${check.type}] ${check.description}${reason}`;
+        }
+    }
+    /**
+     * Get the transcript path for a given repair attempt.
+     */
+    getRepairTranscriptPath(context, attempt) {
+        const dir = path.dirname(context.transcriptPath);
+        return path.join(dir, `repair-attempt-${attempt}.md`);
+    }
+    /**
+     * Get git diff for a branch. Returns empty string on failure.
+     */
+    getGitDiff(_branchName) {
+        try {
+            const diff = (0, child_process_1.execSync)(`git diff HEAD~1 --stat 2>/dev/null || echo ""`, {
+                cwd: this.workingDir,
+                encoding: 'utf8',
+                timeout: 10000
+            });
+            return diff.trim();
+        }
+        catch {
+            // Git diff unavailable (no prior commit, detached HEAD); non-critical for repair
+            return '';
+        }
+    }
+}
+exports.RepairAgent = RepairAgent;
+exports.default = RepairAgent;