swarm-orchestrator 7.0.0-alpha.0

package/dist/src/pr-manager.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRManager = void 0;
+const child_process_1 = require("child_process");
+const defaults_1 = require("./defaults");
+const GH_AUTH_CHECK_TIMEOUT_MS = 1_000;
+/**
+ * Per-step PR lifecycle management.
+ *
+ * Creates PRs for verified step branches, attaches verification evidence
+ * and cost attribution as comments, and handles auto-merge or review-wait
+ * depending on the configured mode.
+ */
+class PRManager {
+    workingDir;
+    ghAvailable = null;
+    constructor(workingDir) {
+        this.workingDir = workingDir || process.cwd();
+    }
+    /**
+     * Check whether the gh CLI is installed and authenticated.
+     * Caches the result for the lifetime of this instance.
+     */
+    isGhAvailable() {
+        if (this.ghAvailable !== null)
+            return this.ghAvailable;
+        try {
+            (0, child_process_1.execSync)('gh auth status', {
+                cwd: this.workingDir,
+                stdio: 'pipe',
+                timeout: GH_AUTH_CHECK_TIMEOUT_MS,
+            });
+            this.ghAvailable = true;
+        }
+        catch {
+            this.ghAvailable = false;
+        }
+        return this.ghAvailable;
+    }
+    /**
+     * Create a PR for a step branch with verification evidence attached.
+     */
+    createStepPR(branchName, baseBranch, stepNumber, agentName, taskDescription, content) {
+        if (!this.isGhAvailable()) {
+            return { success: false, error: 'gh CLI not available or not authenticated. Install gh and run "gh auth login" to use --pr mode.' };
+        }
+        const title = `[Swarm Step ${stepNumber}] ${agentName}: ${this.truncate(taskDescription, 60)}`;
+        const body = this.formatPRBody(stepNumber, agentName, taskDescription, content);
+        try {
+            // Push the branch to remote before creating the PR
+            try {
+                (0, child_process_1.execSync)(`git push -u origin "${branchName}"`, {
+                    cwd: this.workingDir,
+                    stdio: 'pipe',
+                    timeout: defaults_1.DEFAULT_CONTEXT_LOCK_WAIT_MS
+                });
+            }
+            catch (pushErr) {
+                const pushMsg = pushErr instanceof Error ? pushErr.message : String(pushErr);
+                // If the branch already exists on remote, that's fine
+                if (!pushMsg.includes('already exists') && !pushMsg.includes('Everything up-to-date')) {
+                    return { success: false, error: `Failed to push branch ${branchName}: ${pushMsg}` };
+                }
+            }
+            const output = (0, child_process_1.execSync)(`gh pr create --base "${baseBranch}" --head "${branchName}" --title "${this.escapeShell(title)}" --body "${this.escapeShell(body)}"`, {
+                cwd: this.workingDir,
+                encoding: 'utf8',
+                stdio: 'pipe',
+                timeout: defaults_1.DEFAULT_CONTEXT_LOCK_WAIT_MS
+            });
+            const url = this.extractUrl(output);
+            const prNumber = this.extractPRNumber(url || output);
+            const result = { success: true };
+            if (url)
+                result.url = url;
+            if (prNumber !== undefined)
+                result.number = prNumber;
+            return result;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { success: false, error: `PR creation failed for ${branchName}: ${msg}` };
+        }
+    }
+    /**
+     * Add a cost attribution comment to an existing PR.
+     */
+    addCostComment(prNumber, costRecord) {
+        const comment = this.formatCostComment(costRecord);
+        return this.addComment(prNumber, comment);
+    }
+    /**
+     * Add quality gate results as a comment to an existing PR.
+     */
+    addGateResultsComment(prNumber, gateResults) {
+        const comment = this.formatGateResultsComment(gateResults);
+        return this.addComment(prNumber, comment);
+    }
+    /**
+     * Auto-merge a PR if all checks pass, using the merge commit strategy.
+     */
+    autoMergePR(prNumber) {
+        try {
+            (0, child_process_1.execSync)(`gh pr merge ${prNumber} --merge --auto`, {
+                cwd: this.workingDir,
+                stdio: 'pipe',
+                timeout: defaults_1.DEFAULT_BRANCH_SWITCH_TIMEOUT_MS
+            });
+            return true;
+        }
+        catch {
+            // Auto-merge may not be enabled on the repo; fall back to immediate merge
+            try {
+                (0, child_process_1.execSync)(`gh pr merge ${prNumber} --merge`, {
+                    cwd: this.workingDir,
+                    stdio: 'pipe',
+                    timeout: defaults_1.DEFAULT_BRANCH_SWITCH_TIMEOUT_MS
+                });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    /**
+     * Poll PR status until it is approved or merged.
+     * Returns once the PR leaves the OPEN+unapproved state.
+     * Times out after maxWaitMs (default: 30 minutes).
+     */
+    async waitForApproval(prNumber, pollIntervalMs = defaults_1.DEFAULT_BRANCH_SWITCH_TIMEOUT_MS, maxWaitMs = 1_800_000) {
+        const deadline = Date.now() + maxWaitMs;
+        while (Date.now() < deadline) {
+            const status = this.getPRStatus(prNumber);
+            if (status.state === 'MERGED' || status.state === 'CLOSED') {
+                return status;
+            }
+            if (status.approved) {
+                return status;
+            }
+            await this.sleep(pollIntervalMs);
+        }
+        return { state: 'OPEN', approved: false, reviewDecision: 'TIMEOUT' };
+    }
+    /**
+     * Get current PR status, review decision, and mergeability.
+     */
+    getPRStatus(prNumber) {
+        try {
+            const output = (0, child_process_1.execSync)(`gh pr view ${prNumber} --json state,reviewDecision,mergeable`, {
+                cwd: this.workingDir,
+                encoding: 'utf8',
+                stdio: 'pipe',
+                timeout: defaults_1.DEFAULT_CONTEXT_LOCK_WAIT_MS
+            });
+            const data = JSON.parse(output);
+            return {
+                state: data.state || 'OPEN',
+                approved: data.reviewDecision === 'APPROVED',
+                reviewDecision: data.reviewDecision,
+                mergeable: data.mergeable
+            };
+        }
+        catch {
+            return { state: 'OPEN', approved: false };
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Formatting
+    // ---------------------------------------------------------------------------
+    /**
+     * Compose the PR body with verification evidence.
+     */
+    formatPRBody(stepNumber, agentName, taskDescription, content) {
+        const lines = [];
+        lines.push(`## Swarm Step ${stepNumber}: ${agentName}`);
+        lines.push('');
+        lines.push(`**Task:** ${taskDescription}`);
+        lines.push('');
+        if (content.verification) {
+            lines.push('### Verification');
+            lines.push('');
+            lines.push(this.formatVerificationEvidence(content.verification));
+        }
+        if (content.costRecord) {
+            lines.push('### Cost Attribution');
+            lines.push('');
+            lines.push(this.formatCostComment(content.costRecord));
+        }
+        if (content.gateResults && content.gateResults.length > 0) {
+            lines.push('### Quality Gates');
+            lines.push('');
+            lines.push(this.formatGateResultsComment(content.gateResults));
+        }
+        lines.push('---');
+        lines.push('*Generated by Swarm Orchestrator*');
+        return lines.join('\n');
+    }
+    /**
+     * Format a VerificationResult into a markdown evidence summary.
+     */
+    formatVerificationEvidence(result) {
+        const lines = [];
+        const icon = result.passed ? '✅' : '❌';
+        lines.push(`${icon} **Verification ${result.passed ? 'Passed' : 'Failed'}**`);
+        lines.push('');
+        if (result.checks.length > 0) {
+            lines.push('| Check | Type | Required | Status | Evidence |');
+            lines.push('|-------|------|----------|--------|----------|');
+            for (const check of result.checks) {
+                const statusIcon = check.passed ? '✓' : '✗';
+                const evidence = check.evidence ? this.truncate(check.evidence, 80) : (check.reason || '');
+                lines.push(`| ${check.description} | ${check.type} | ${check.required ? 'Yes' : 'No'} | ${statusIcon} | ${evidence} |`);
+            }
+            lines.push('');
+        }
+        if (result.unverifiedClaims.length > 0) {
+            lines.push(`**Unverified claims (${result.unverifiedClaims.length}):**`);
+            for (const claim of result.unverifiedClaims) {
+                lines.push(`- ${this.truncate(claim, 120)}`);
+            }
+            lines.push('');
+        }
+        if (result.gracefulFailure) {
+            lines.push(`> **Note:** This step was allowed to continue despite verification failure.`);
+            if (result.degradationReason) {
+                lines.push(`> Reason: ${result.degradationReason}`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format cost attribution for a comment.
+     */
+    formatCostComment(record) {
+        const lines = [];
+        lines.push(`| Metric | Value |`);
+        lines.push(`|--------|-------|`);
+        lines.push(`| Estimated Premium Requests | ${record.estimatedPremiumRequests} |`);
+        lines.push(`| Actual Premium Requests | ${record.actualPremiumRequests} |`);
+        lines.push(`| Retry Count | ${record.retryCount} |`);
+        lines.push(`| Prompt Tokens | ${record.promptTokens} |`);
+        lines.push(`| Fleet Mode | ${record.fleetMode ? 'Yes' : 'No'} |`);
+        lines.push(`| Duration | ${(record.durationMs / 1000).toFixed(1)}s |`);
+        return lines.join('\n');
+    }
+    /**
+     * Format quality gate results for a PR comment.
+     */
+    formatGateResultsComment(gateResults) {
+        const lines = [];
+        const allPassed = gateResults.every(g => g.status !== 'fail');
+        const icon = allPassed ? '✅' : '⚠️';
+        lines.push(`${icon} **Quality Gates: ${allPassed ? 'All Passed' : 'Issues Found'}**`);
+        lines.push('');
+        lines.push('| Gate | Status | Issues |');
+        lines.push('|------|--------|--------|');
+        for (const gate of gateResults) {
+            const statusIcon = gate.status === 'pass' ? '✓' : gate.status === 'fail' ? '✗' : '⊘';
+            lines.push(`| ${gate.title} | ${statusIcon} ${gate.status} | ${gate.issues.length} |`);
+        }
+        // Show top issues for failed gates
+        const failedGates = gateResults.filter(g => g.status === 'fail');
+        if (failedGates.length > 0) {
+            lines.push('');
+            lines.push('**Issues:**');
+            for (const gate of failedGates) {
+                const topIssues = gate.issues.slice(0, 5);
+                for (const issue of topIssues) {
+                    const loc = issue.filePath ? `${issue.filePath}${issue.line ? ':' + issue.line : ''}` : '';
+                    lines.push(`- ${loc ? `\`${loc}\` ` : ''}${issue.message}`);
+                }
+                if (gate.issues.length > 5) {
+                    lines.push(`- ... and ${gate.issues.length - 5} more`);
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    // ---------------------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------------------
+    addComment(prNumber, body) {
+        try {
+            (0, child_process_1.execSync)(`gh pr comment ${prNumber} --body "${this.escapeShell(body)}"`, {
+                cwd: this.workingDir,
+                stdio: 'pipe',
+                timeout: defaults_1.DEFAULT_BRANCH_SWITCH_TIMEOUT_MS
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    extractUrl(output) {
+        const match = output.match(/(https:\/\/github\.com\/[^\s]+)/);
+        return match ? match[1] : undefined;
+    }
+    extractPRNumber(text) {
+        const match = text.match(/\/pull\/(\d+)/);
+        return match ? parseInt(match[1], 10) : undefined;
+    }
+    truncate(text, maxLen) {
+        if (text.length <= maxLen)
+            return text;
+        return text.substring(0, maxLen - 3) + '...';
+    }
+    escapeShell(str) {
+        return str.replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`');
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.PRManager = PRManager;
+exports.default = PRManager;

package/dist/src/presenter/index.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Presenter: owns the user-facing CLI surface (banners, summary blocks,
+ * results, footers). Writes to stdout. Color and glyph aware. Quiet-respecting.
+ *
+ * The logger (`src/logger.ts`) is for diagnostics and goes to stderr (when
+ * routed there); the presenter is for users and goes to stdout. These are
+ * two different concerns. Today's code conflates them.
+ *
+ * Live progress (spinner, in-place step status) lives in `cli/live-status.ts`.
+ * The presenter handles static surfaces; LiveStatus handles the moving parts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Presenter = void 0;
+exports.getPresenter = getPresenter;
+exports.configurePresenter = configurePresenter;
+exports._setPresenterForTest = _setPresenterForTest;
+const ESC = '\x1b[';
+const UTF8_GLYPHS = {
+    check: '✓',
+    cross: '✗',
+    bang: '!',
+    dot: '·',
+    sep: '·',
+};
+const ASCII_GLYPHS = {
+    check: 'v',
+    cross: 'x',
+    bang: '!',
+    dot: '.',
+    sep: '.',
+};
+function detectAscii() {
+    if (process.env.SWARM_ASCII === '1')
+        return true;
+    const lc = (process.env.LC_ALL || process.env.LC_CTYPE || process.env.LANG || '').toLowerCase();
+    if (!lc)
+        return false;
+    return !lc.includes('utf');
+}
+function detectColor(stream) {
+    if (process.env.NO_COLOR)
+        return false;
+    if (process.env.CI)
+        return false;
+    return Boolean(stream.isTTY);
+}
+class Presenter {
+    out;
+    theme;
+    quiet;
+    constructor(opts = {}) {
+        this.out = opts.out ?? process.stdout;
+        this.theme = {
+            color: opts.color ?? detectColor(this.out),
+            ascii: opts.ascii ?? detectAscii(),
+        };
+        this.quiet = opts.quiet ?? false;
+    }
+    /** Public for the live-status / debug paths that need to render a glyph. */
+    glyph(g) {
+        return this.theme.ascii ? ASCII_GLYPHS[g] : UTF8_GLYPHS[g];
+    }
+    dim(s) {
+        return this.theme.color ? `${ESC}2m${s}${ESC}22m` : s;
+    }
+    bold(s) {
+        return this.theme.color ? `${ESC}1m${s}${ESC}22m` : s;
+    }
+    green(s) {
+        return this.theme.color ? `${ESC}32m${s}${ESC}39m` : s;
+    }
+    red(s) {
+        return this.theme.color ? `${ESC}31m${s}${ESC}39m` : s;
+    }
+    yellow(s) {
+        return this.theme.color ? `${ESC}33m${s}${ESC}39m` : s;
+    }
+    cyan(s) {
+        return this.theme.color ? `${ESC}36m${s}${ESC}39m` : s;
+    }
+    /** Raw write of a line. The static surface emits through this. */
+    print(line) {
+        if (this.quiet)
+            return;
+        this.out.write(line + '\n');
+    }
+    blank() {
+        if (this.quiet)
+            return;
+        this.out.write('\n');
+    }
+    /** Goal echo at the start of a `run` invocation. */
+    runHeader(goal) {
+        if (this.quiet)
+            return;
+        this.print(`swarm run`);
+        this.print(`${this.dim(this.glyph('dot'))} ${goal}`);
+        this.blank();
+    }
+    /** Goal echo at the start of a `swarm <plan>` invocation. */
+    swarmHeader(goal) {
+        if (this.quiet)
+            return;
+        this.print(`swarm`);
+        this.print(`${this.dim(this.glyph('dot'))} ${goal}`);
+        this.blank();
+    }
+    planSummary(s) {
+        if (this.quiet)
+            return;
+        const stepsLabel = `${s.steps} step${s.steps === 1 ? '' : 's'}`;
+        const modelFrag = `${s.model} ${s.modelMultiplier}×`;
+        const retryFrag = `${s.retryPct}% retry buffer`;
+        this.print(`  ${this.dim('plan')}     ${stepsLabel} ${this.dim(this.glyph('sep'))} ${modelFrag} ${this.dim(this.glyph('sep'))} ${retryFrag}`);
+        this.print(`  ${this.dim('cost')}     ${s.costRange} premium request${s.costRange === '1' ? '' : 's'}`);
+        if (s.remediationBuffer && s.remediationBuffer > 0) {
+            this.print(`           ${this.dim(`+${s.remediationBuffer} remediation buffer`)}`);
+        }
+        if (s.innerFleet) {
+            this.print(`           ${this.dim('/fleet subagent multiplier applied')}`);
+        }
+        if (s.target) {
+            this.print(`  ${this.dim('target')}   ${s.target}`);
+        }
+        this.blank();
+    }
+    runStarted(r) {
+        if (this.quiet)
+            return;
+        this.print(`  ${this.dim('run')}      ${r.runDir}`);
+        this.blank();
+    }
+    /** Single-line status while final quality gates run. */
+    gateRunningStart() {
+        if (this.quiet)
+            return;
+        this.print(`  ${this.dim('running quality gates...')}`);
+    }
+    cancelled() {
+        if (this.quiet)
+            return;
+        this.print(`  ${this.dim('cancelled')}`);
+    }
+    finalSummary(f) {
+        const sep = this.dim(this.glyph('sep'));
+        const headlineGlyph = f.ok ? this.green(this.glyph('check')) : this.red(this.glyph('cross'));
+        const headlineWord = f.ok ? 'done' : `${f.failedSteps?.length ?? f.total - f.completed} failed`;
+        const fragments = [`${f.completed}/${f.total} step${f.total === 1 ? '' : 's'}`];
+        if (f.duration)
+            fragments.push(f.duration);
+        fragments.push(`${f.premiumRequests} premium request${f.premiumRequests === 1 ? '' : 's'}`);
+        if (typeof f.gatesPassed === 'number' || typeof f.gatesFailed === 'number') {
+            const passed = f.gatesPassed ?? 0;
+            const failed = f.gatesFailed ?? 0;
+            const gateNote = failed === 0
+                ? `${passed} gate${passed === 1 ? '' : 's'} passed`
+                : `${passed} gates passed ${this.dim(this.glyph('sep'))} ${failed} failed`;
+            fragments.push(gateNote);
+        }
+        // Headline always prints, even in quiet mode (it's the result).
+        this.out.write(`  ${headlineGlyph} ${this.bold(headlineWord)} ${sep} ${fragments.join(` ${sep} `)}\n`);
+        if (this.quiet)
+            return;
+        if (f.failedSteps && f.failedSteps.length > 0) {
+            this.blank();
+            for (const fs of f.failedSteps) {
+                this.print(`    ${this.red(this.glyph('cross'))} step-${fs.stepNumber} ${this.dim(fs.agentName)} ${sep} ${fs.reason}`);
+            }
+        }
+        if (f.estimateExceededPct !== undefined && f.estimateExceededPct > 20) {
+            this.print(`    ${this.dim(`exceeded estimate by ${f.estimateExceededPct}% (estimate ${f.estimateLow ?? '?'}–${f.estimateHigh ?? '?'})`)}`);
+        }
+        if (f.remediationSteps && f.remediationSteps > 0) {
+            this.print(`    ${this.dim(`${f.plannedSteps} planned + ${f.remediationSteps} remediation`)}`);
+        }
+        this.print(`  ${this.dim('artifacts')} ${f.artifactsDir}`);
+        if (f.prUrls && f.prUrls.size > 0) {
+            for (const [stepNum, url] of f.prUrls) {
+                this.print(`  ${this.dim(`pr step-${stepNum}`)} ${url}`);
+            }
+        }
+        if (!f.ok && f.inspectCommand) {
+            this.blank();
+            this.print(`  ${this.dim(`inspect: ${f.inspectCommand}`)}`);
+        }
+        this.blank();
+    }
+}
+exports.Presenter = Presenter;
+let singleton;
+/**
+ * Returns the process-wide presenter singleton. Created on first access with
+ * default options (color/ascii detected from env, quiet=false). Tests should
+ * use `_setPresenterForTest` to inject a controlled instance.
+ */
+function getPresenter() {
+    if (!singleton)
+        singleton = new Presenter();
+    return singleton;
+}
+/** Reconfigure the singleton (e.g. after parsing --quiet from argv). */
+function configurePresenter(opts) {
+    singleton = new Presenter(opts);
+}
+/** Test hook. */
+function _setPresenterForTest(instance) {
+    singleton = instance;
+}