swarm-orchestrator 7.0.0-alpha.0

package/dist/src/copilot-cli-wrapper.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Copilot CLI Wrapper
+ *
+ * Abstraction layer for resilient Copilot CLI invocation with:
+ * - Graceful degradation when CLI unavailable
+ * - Fallback to alternative modes
+ * - Better error handling and retry logic
+ * - Feature detection and capability checking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopilotCliWrapper = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('copilot-cli-wrapper');
+/**
+ * Wrapper for GitHub Copilot CLI with resilience features
+ */
+class CopilotCliWrapper {
+    options;
+    capabilities = null;
+    capabilityCheckDone = false;
+    constructor(options = {}) {
+        this.options = options;
+        // Default options
+        this.options.gracefulDegradation = this.options.gracefulDegradation ?? true;
+        this.options.retryOnFailure = this.options.retryOnFailure ?? true;
+        this.options.maxRetries = this.options.maxRetries ?? 3;
+        this.options.timeout = this.options.timeout ?? 300000; // 5 minutes
+    }
+    /**
+     * Check if Copilot CLI is available and what features it supports
+     */
+    async checkCapabilities() {
+        if (this.capabilityCheckDone && this.capabilities) {
+            return this.capabilities;
+        }
+        const capabilities = {
+            available: false,
+            supportsPromptMode: false,
+            supportsShare: false,
+            supportsAgents: false,
+            supportsMcp: false
+        };
+        try {
+            // Check if copilot command exists
+            const versionResult = await this.runCommand('copilot', ['--version'], { timeout: 5000 });
+            if (versionResult.exitCode === 0) {
+                capabilities.available = true;
+                capabilities.version = versionResult.stdout.trim();
+                // Check for -p flag support
+                const helpResult = await this.runCommand('copilot', ['--help'], { timeout: 5000 });
+                capabilities.supportsPromptMode = helpResult.stdout.includes('-p');
+                capabilities.supportsShare = helpResult.stdout.includes('--share');
+                capabilities.supportsAgents = helpResult.stdout.includes('--agent');
+                capabilities.supportsMcp = helpResult.stdout.includes('--mcp');
+            }
+        }
+        catch {
+            // CLI not available
+            capabilities.available = false;
+        }
+        this.capabilities = capabilities;
+        this.capabilityCheckDone = true;
+        return capabilities;
+    }
+    /**
+     * Execute a Copilot CLI command with resilience
+     */
+    async execute(args, options = {}) {
+        // Strict isolation guard: log when active so transcript captures the mode
+        if (this.options.strictIsolation) {
+            logger.info('[strict-isolation] Per-task branch isolation active. Context restricted to transcript evidence only.');
+        }
+        // Inner fleet toggle: prepend /fleet to prompt input
+        if (this.options.useInnerFleet && options.input) {
+            logger.info('[inner-fleet] Inner fleet mode active. External safety rail enforced.');
+            options = { ...options, input: `/fleet ${options.input}` };
+        }
+        const capabilities = await this.checkCapabilities();
+        if (!capabilities.available) {
+            if (this.options.gracefulDegradation) {
+                return this.degradedExecution(args, options);
+            }
+            else {
+                return {
+                    success: false,
+                    output: '',
+                    error: 'Copilot CLI is not available. Please install it with: npm install -g @github/copilot',
+                    exitCode: 127,
+                    degraded: false,
+                    capabilities
+                };
+            }
+        }
+        // Execute with retries
+        let lastError = '';
+        for (let attempt = 1; attempt <= (this.options.maxRetries || 1); attempt++) {
+            try {
+                const runOptions = {};
+                if (options.cwd)
+                    runOptions.cwd = options.cwd;
+                if (this.options.timeout)
+                    runOptions.timeout = this.options.timeout;
+                if (options.input)
+                    runOptions.input = options.input;
+                const result = await this.runCommand('copilot', args, runOptions);
+                return {
+                    success: result.exitCode === 0,
+                    output: result.stdout + result.stderr,
+                    error: result.exitCode !== 0 ? result.stderr : undefined,
+                    exitCode: result.exitCode,
+                    degraded: false,
+                    capabilities
+                };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error.message : String(error);
+                if (attempt < (this.options.maxRetries || 1)) {
+                    // Wait before retry with exponential backoff
+                    await this.sleep(Math.pow(2, attempt) * 1000);
+                }
+            }
+        }
+        // All retries failed
+        if (this.options.gracefulDegradation) {
+            return this.degradedExecution(args, options);
+        }
+        return {
+            success: false,
+            output: '',
+            error: `Failed after ${this.options.maxRetries} attempts: ${lastError}`,
+            exitCode: 1,
+            degraded: false,
+            capabilities
+        };
+    }
+    /**
+     * Degraded execution mode when CLI unavailable or failing
+     * Provides helpful guidance instead of hard failure
+     */
+    degradedExecution(args, options) {
+        const capabilities = this.capabilities || {
+            available: false,
+            supportsPromptMode: false,
+            supportsShare: false,
+            supportsAgents: false,
+            supportsMcp: false
+        };
+        // Generate helpful message based on what was attempted
+        let message = '⚠️  Graceful Degradation Mode\n\n';
+        message += 'The Copilot CLI is not available or failed to execute.\n';
+        message += 'This would have run: copilot ' + args.join(' ') + '\n\n';
+        if (options.input) {
+            message += 'With prompt:\n';
+            message += '---\n';
+            message += options.input.substring(0, 500);
+            if (options.input.length > 500) {
+                message += '\n... (truncated)';
+            }
+            message += '\n---\n\n';
+        }
+        message += 'To use this feature:\n';
+        message += '1. Install Copilot CLI: npm install -g @github/copilot\n';
+        message += '2. Authenticate: copilot auth\n';
+        message += '3. Re-run this command\n\n';
+        message += 'Or, execute the prompt manually in your terminal.';
+        return {
+            success: false,
+            output: message,
+            error: 'Copilot CLI not available (degraded mode)',
+            exitCode: 0, // Don't fail hard
+            degraded: true,
+            capabilities
+        };
+    }
+    /**
+     * Run a command and capture output
+     */
+    runCommand(command, args, options = {}) {
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)(command, args, {
+                cwd: options.cwd || process.cwd(),
+                shell: true
+            });
+            let stdout = '';
+            let stderr = '';
+            let timedOut = false;
+            // Set timeout if specified
+            const timeoutId = options.timeout
+                ? setTimeout(() => {
+                    timedOut = true;
+                    proc.kill('SIGTERM');
+                }, options.timeout)
+                : null;
+            if (proc.stdout) {
+                proc.stdout.on('data', (data) => {
+                    stdout += data.toString();
+                });
+            }
+            if (proc.stderr) {
+                proc.stderr.on('data', (data) => {
+                    stderr += data.toString();
+                });
+            }
+            // Send input if provided
+            if (options.input && proc.stdin) {
+                proc.stdin.write(options.input);
+                proc.stdin.end();
+            }
+            proc.on('close', (code) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (timedOut) {
+                    resolve({
+                        stdout,
+                        stderr: stderr + '\nCommand timed out',
+                        exitCode: 124
+                    });
+                }
+                else {
+                    resolve({
+                        stdout,
+                        stderr,
+                        exitCode: code || 0
+                    });
+                }
+            });
+            proc.on('error', (err) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                resolve({
+                    stdout,
+                    stderr: stderr + '\n' + err.message,
+                    exitCode: 127
+                });
+            });
+        });
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Get current capabilities (cached)
+     */
+    getCapabilities() {
+        return this.capabilities;
+    }
+    /**
+     * Reset capability cache (for testing)
+     */
+    resetCapabilities() {
+        this.capabilities = null;
+        this.capabilityCheckDone = false;
+    }
+}
+exports.CopilotCliWrapper = CopilotCliWrapper;
+exports.default = CopilotCliWrapper;

package/dist/src/cost-estimator.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostEstimator = exports.MODEL_MULTIPLIERS = void 0;
+const defaults_1 = require("./defaults");
+/**
+ * Model multipliers for premium request consumption.
+ * Each copilot -p invocation = 1 base premium request * multiplier.
+ * Updated as GitHub changes pricing: https://docs.github.com/en/copilot/concepts/billing/copilot-requests
+ * Model availability varies by Copilot plan; Copilot CLI will reject
+ * unavailable models at runtime with "not available" on stderr.
+ */
+exports.MODEL_MULTIPLIERS = {
+    'claude-sonnet-4': 1,
+    'claude-sonnet-4.6': 1,
+    'claude-opus-4': 1,
+    'gpt-4o': 1,
+    'gpt-5.2': 1,
+    'gpt-5.4': 1,
+    'o3': 20,
+    'o4-mini': 5,
+};
+const MAX_RETRY_PROBABILITY = 0.50;
+const OVERAGE_COST_PER_REQUEST = 0.04;
+// Quality gate remediation overhead: proportion of planned steps that
+// typically trigger remediation follow-ups. Derived from observed runs
+// where ~29% of total requests were gate-triggered remediation steps.
+// Rounded down to 0.25 as a conservative default. Applied per-step, then
+// ceiled to whole requests since partial agent invocations aren't possible.
+const MAX_REMEDIATION_RATE = 0.50;
+// Rough token count for the static boilerplate injected by buildSwarmPrompt.
+// Measured from actual prompt captures; chars / 4 approximation.
+const STATIC_BOILERPLATE_TOKENS = 350;
+class CostEstimator {
+    knowledgeBase;
+    actuals = [];
+    constructor(knowledgeBase) {
+        this.knowledgeBase = knowledgeBase;
+    }
+    estimate(plan, options) {
+        const multiplier = exports.MODEL_MULTIPLIERS[options.modelName] ?? 1;
+        let retryProbability = this.calibrateRetryProbability(plan);
+        // Gate-aware prompts reduce repair cycles by front-loading requirements.
+        // Conservative estimate: 30% reduction in retry probability.
+        if (options.gateAwarePrompts) {
+            retryProbability *= 0.7;
+        }
+        const perStep = plan.steps.map(step => {
+            const taskTokens = Math.ceil(step.task.length / 4);
+            const promptTokens = STATIC_BOILERPLATE_TOKENS + taskTokens;
+            const baseRequests = 1 * multiplier;
+            const fleetMultiplier = options.fleetMode
+                ? this.estimateFleetMultiplier(step.task)
+                : 1;
+            // Per-step estimate is the base cost without retry inflation.
+            // Retry buffer is calculated as an aggregate across the plan.
+            const stepRequests = baseRequests * fleetMultiplier;
+            return {
+                stepNumber: step.stepNumber,
+                agentName: step.agentName,
+                estimatedPromptTokens: promptTokens,
+                estimatedPremiumRequests: stepRequests,
+                retryProbability,
+                rationale: this.buildRationale(multiplier, fleetMultiplier, retryProbability, options),
+            };
+        });
+        const baseTotalNoRetry = perStep.reduce((sum, s) => sum + s.estimatedPremiumRequests, 0);
+        // Retry buffer is the aggregate expected retry cost across all steps
+        const retryBuffer = Math.ceil(baseTotalNoRetry * retryProbability);
+        // Remediation buffer: when quality gates are enabled, some steps will
+        // fail gate checks and trigger automated follow-up remediation steps.
+        // Each remediation step costs one premium request per model multiplier.
+        const remediationRate = options.qualityGatesEnabled
+            ? this.calibrateRemediationRate(plan)
+            : 0;
+        const remediationBuffer = Math.ceil(plan.steps.length * remediationRate * multiplier);
+        const totalRaw = baseTotalNoRetry + retryBuffer + remediationBuffer;
+        // Low estimate assumes no retries and no remediation
+        const lowEstimate = baseTotalNoRetry;
+        const highEstimate = totalRaw;
+        const overageCostUSD = options.remainingAllowance !== undefined
+            ? Math.max(0, totalRaw - options.remainingAllowance) * OVERAGE_COST_PER_REQUEST
+            : 0;
+        return {
+            totalPremiumRequests: totalRaw,
+            lowEstimate,
+            highEstimate,
+            perStep,
+            retryBuffer: Math.max(0, retryBuffer),
+            remediationBuffer,
+            modelMultiplier: multiplier,
+            overageCostUSD: parseFloat(overageCostUSD.toFixed(2)),
+            ...(options.remainingAllowance !== undefined
+                ? { remainingAllowance: options.remainingAllowance }
+                : {}),
+        };
+    }
+    recordActual(stepNumber, estimatedRequests, actualRequests, retryCount) {
+        this.actuals.push({ stepNumber, estimatedRequests, actualRequests, retryCount });
+    }
+    /**
+     * Ratio of correctly-estimated steps to total recorded steps.
+     * A step is "correct" if estimated >= actual (no underestimate).
+     * Returns 1.0 when no actuals recorded (no data to disprove accuracy).
+     */
+    getAccuracy() {
+        if (this.actuals.length === 0)
+            return 1.0;
+        const totalEstimated = this.actuals.reduce((s, a) => s + a.estimatedRequests, 0);
+        const totalActual = this.actuals.reduce((s, a) => s + a.actualRequests, 0);
+        if (totalActual === 0)
+            return 1.0;
+        // Conservative overestimates are acceptable; only penalize underestimates.
+        // Accuracy for overestimates: actual / estimated (closer to 1 = tighter).
+        // Accuracy for underestimates: estimated / actual (penalizes gaps).
+        if (totalEstimated >= totalActual) {
+            return totalActual / totalEstimated;
+        }
+        return totalEstimated / totalActual;
+    }
+    /**
+     * Pull historical failure rate from knowledge base cost_history patterns.
+     * Falls back to DEFAULT_RETRY_PROBABILITY when no history exists.
+     * Parses structured CostHistoryEvidence from evidence array.
+     * Falls back to legacy string parsing for pre-v3.3 entries.
+     */
+    calibrateRetryProbability(_plan) {
+        if (!this.knowledgeBase)
+            return defaults_1.DEFAULT_RETRY_PROBABILITY;
+        const costPatterns = this.knowledgeBase.getPatternsByCategory('cost_history');
+        if (costPatterns.length === 0)
+            return defaults_1.DEFAULT_RETRY_PROBABILITY;
+        let totalRetries = 0;
+        let totalSteps = 0;
+        for (const pattern of costPatterns) {
+            // Try structured evidence first (single JSON string per entry)
+            const parsed = this.parseStructuredEvidence(pattern.evidence);
+            if (parsed) {
+                totalSteps += parsed.actual;
+                totalRetries += parsed.retries;
+                continue;
+            }
+            // Legacy fallback: string-encoded fields
+            for (const ev of pattern.evidence) {
+                if (ev.startsWith('actual:')) {
+                    const actual = parseInt(ev.split(':')[1], 10);
+                    if (!isNaN(actual))
+                        totalSteps += actual;
+                }
+            }
+            const retryMatch = pattern.insight.match(/(\d+)\s+retries/);
+            if (retryMatch) {
+                totalRetries += parseInt(retryMatch[1], 10);
+            }
+        }
+        if (totalSteps === 0)
+            return defaults_1.DEFAULT_RETRY_PROBABILITY;
+        const rate = totalRetries / totalSteps;
+        return Math.min(rate, MAX_RETRY_PROBABILITY);
+    }
+    /**
+     * Pull historical remediation rate from knowledge base cost_history patterns.
+     * Remediation steps are quality-gate-triggered follow-ups (not retries).
+     * Falls back to DEFAULT_REMEDIATION_RATE when no history with remediation
+     * data exists. Only structured evidence (v4.2+) carries remediation counts.
+     */
+    calibrateRemediationRate(_plan) {
+        if (!this.knowledgeBase)
+            return defaults_1.DEFAULT_REMEDIATION_RATE;
+        const costPatterns = this.knowledgeBase.getPatternsByCategory('cost_history');
+        if (costPatterns.length === 0)
+            return defaults_1.DEFAULT_REMEDIATION_RATE;
+        let totalPlannedSteps = 0;
+        let totalRemediationSteps = 0;
+        for (const pattern of costPatterns) {
+            const parsed = this.parseStructuredEvidence(pattern.evidence);
+            if (!parsed)
+                continue;
+            if (typeof parsed.remediationSteps !== 'number')
+                continue;
+            totalPlannedSteps += parsed.steps;
+            totalRemediationSteps += parsed.remediationSteps;
+        }
+        if (totalPlannedSteps === 0)
+            return defaults_1.DEFAULT_REMEDIATION_RATE;
+        const rate = totalRemediationSteps / totalPlannedSteps;
+        return Math.min(rate, MAX_REMEDIATION_RATE);
+    }
+    /**
+     * Attempt to parse a CostHistoryEvidence object from the evidence array.
+     * Returns null if the evidence uses the legacy string format.
+     */
+    parseStructuredEvidence(evidence) {
+        if (evidence.length !== 1)
+            return null;
+        try {
+            const obj = JSON.parse(evidence[0]);
+            if (typeof obj.runId === 'string' && typeof obj.actual === 'number') {
+                return obj;
+            }
+        }
+        catch {
+            // Not JSON; legacy format
+        }
+        return null;
+    }
+    /**
+     * Heuristic fleet multiplier: tasks mentioning multiple files or components
+     * likely trigger more subagents.
+     */
+    estimateFleetMultiplier(taskDescription) {
+        const lower = taskDescription.toLowerCase();
+        const multiFileIndicators = [
+            'multiple files', 'several files', 'all files',
+            'each module', 'every module', 'across modules',
+            'components', 'services', 'endpoints',
+        ];
+        const matchCount = multiFileIndicators.filter(ind => lower.includes(ind)).length;
+        if (matchCount >= 2)
+            return 4;
+        if (matchCount === 1)
+            return 3;
+        // Check for list-like patterns (commas separating items in the task)
+        const commaSegments = taskDescription.split(',').length;
+        if (commaSegments >= 4)
+            return 3;
+        if (commaSegments >= 2)
+            return 2;
+        return 2; // fleet always spawns at least one subagent beyond the coordinator
+    }
+    buildRationale(multiplier, fleetMultiplier, retryProb, options) {
+        const parts = [
+            `${options.modelName} (${multiplier}x)`,
+        ];
+        if (options.fleetMode) {
+            parts.push(`fleet (${fleetMultiplier}x subagents)`);
+        }
+        parts.push(`${(retryProb * 100).toFixed(0)}% retry buffer`);
+        return parts.join(', ');
+    }
+}
+exports.CostEstimator = CostEstimator;

package/dist/src/defaults.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SHORT_CODE_MIN_LENGTH = exports.DEFAULT_URL_MAX_LENGTH = exports.DEFAULT_REMEDIATION_RATE = exports.DEFAULT_RETRY_PROBABILITY = exports.DEFAULT_REPAIR_TRANSCRIPT_CHARS = exports.DEFAULT_REPAIR_REPORT_CHARS = exports.DEFAULT_FAILURE_CONTEXT_CHARS = exports.DEFAULT_COMMAND_TIMEOUT_MS = exports.DEFAULT_BRANCH_SWITCH_TIMEOUT_MS = exports.DEFAULT_DEPENDENCY_WAIT_MS = exports.DEFAULT_CONTEXT_STALE_LOCK_MS = exports.DEFAULT_CONTEXT_LOCK_WAIT_MS = exports.DEFAULT_HEARTBEAT_QUIET_THRESHOLD_MS = exports.DEFAULT_HEARTBEAT_INTERVAL_MS = exports.DEFAULT_SIGKILL_DELAY_MS = void 0;
+exports.DEFAULT_SIGKILL_DELAY_MS = 5_000;
+exports.DEFAULT_HEARTBEAT_INTERVAL_MS = 5_000;
+exports.DEFAULT_HEARTBEAT_QUIET_THRESHOLD_MS = 10_000;
+exports.DEFAULT_CONTEXT_LOCK_WAIT_MS = 30_000;
+exports.DEFAULT_CONTEXT_STALE_LOCK_MS = 300_000;
+exports.DEFAULT_DEPENDENCY_WAIT_MS = 600_000;
+exports.DEFAULT_BRANCH_SWITCH_TIMEOUT_MS = 15_000;
+exports.DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
+exports.DEFAULT_FAILURE_CONTEXT_CHARS = 2_000;
+exports.DEFAULT_REPAIR_REPORT_CHARS = 4_000;
+exports.DEFAULT_REPAIR_TRANSCRIPT_CHARS = 6_000;
+exports.DEFAULT_RETRY_PROBABILITY = 0.15;
+exports.DEFAULT_REMEDIATION_RATE = 0.25;
+exports.DEFAULT_URL_MAX_LENGTH = 2_048;
+exports.DEFAULT_SHORT_CODE_MIN_LENGTH = 7;