@haystackeditor/cli 0.25.1 → 0.27.0

package/dist/commands/triage.js

@@ -1,598 +0,0 @@
-/**
- * triage command — Show Haystack analysis results for a PR.
- *
- * Designed for coding agents to consume. Shows two things:
- *   1. What the auto-fixer is already handling (so the agent doesn't duplicate work)
- *   2. Findings with attribution and fix prompts (so the agent knows what to fix)
- *
- * When called without a PR identifier, reads the last submitted PR from
- * `.haystack/pending-submit.json` (written by `haystack submit`).
- *
- * Accepts a PR identifier in several formats:
- *   haystack triage                      # Last submitted PR
- *   haystack triage 123                  # Uses current repo's owner/repo
- *   haystack triage owner/repo#123       # Fully qualified
- *   haystack triage https://github.com/owner/repo/pull/123
- *
- * Output modes:
- *   --hook    Minimal single-line for session-start hooks
- *   --json    Machine-readable JSON
- *   (default) Rich terminal output
- */
-import chalk from 'chalk';
-import WebSocket from 'ws';
-import { checkAnalysisReady, fetchRatingSynthesis, fetchAutoFixManifest } from '../utils/analysis-api.js';
-import { loadToken } from '../utils/auth.js';
-import { loadPendingSubmit, updatePendingSubmit, clearPendingSubmit } from '../utils/pending-state.js';
-import { parsePrRef } from '../utils/pr-ref.js';
-import { toPublicVerdict } from '../states.js';
-import { withSchema } from '../schema.js';
-import { fetchGitHubJson } from '../utils/haystack-api.js';
-import { githubRestBaseFor } from '../utils/github-api.js';
-// ============================================================================
-// Output formatting
-// ============================================================================
-/**
- * True if the finding is one the auto-fixer is already handling (and thus
- * shouldn't be re-fixed). Correlation is by exact finding id — the same stable id
- * analysis assigns and the fixer echoes back in its manifest. We never compare
- * summary/category text.
- */
-function isAutoFixing(finding, manifest) {
-    if (!finding.id)
-        return false;
-    const items = manifest?.fixedItems ?? [];
-    return items.some((item) => item.id === finding.id);
-}
-function printRichOutput(pr, synthesis, manifest) {
-    const reviewUrl = `https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}`;
-    console.log(`\n  ${chalk.bold(`Haystack Triage: ${pr.owner}/${pr.repo}#${pr.prNumber}`)}\n`);
-    // Alpha output stays intentionally small. Findings remain fully visible below.
-    if (manifest && (manifest.fixedItems.length > 0 || manifest.leftForReview.length > 0)) {
-        const fixed = manifest.fixedItems.length;
-        const remaining = manifest.leftForReview.length;
-        console.log(chalk.dim(`  Fixer: completed · fixed ${fixed}; ${remaining} remain for review.\n`));
-    }
-    // Every customer-facing finding stays visible regardless of fixer state.
-    const findings = synthesis.synthesisDisplay || [];
-    if (findings.length > 0) {
-        console.log(chalk.bold('  Findings to address:\n'));
-        for (let i = 0; i < findings.length; i++) {
-            const finding = findings[i];
-            const sourceTag = finding.source ? ` (${finding.source})` : '';
-            console.log(`  ${i + 1}. [${finding.category}]${sourceTag} ${finding.summary}`);
-            if (finding.detail) {
-                for (const line of finding.detail.split('\n')) {
-                    console.log(`     ${line}`);
-                }
-            }
-            if (finding.agentFixPrompt) {
-                const fixLines = finding.agentFixPrompt.split('\n');
-                console.log(`     ${chalk.dim('Fix:')} ${fixLines[0]}`);
-                for (const line of fixLines.slice(1)) {
-                    console.log(`     ${line}`);
-                }
-            }
-            console.log('');
-        }
-    }
-    else {
-        console.log(chalk.dim('  No findings.\n'));
-    }
-    console.log(`  ${chalk.dim(reviewUrl)}\n`);
-}
-export function buildJsonOutput(pr, headSha, synthesis, manifest) {
-    const payload = {
-        ref: `${pr.owner}/${pr.repo}#${pr.prNumber}`,
-        head_sha: headSha,
-        status: 'complete',
-        verdict: toPublicVerdict(synthesis.analysisVerdict, synthesis.haystackRating),
-        rating: synthesis.haystackRating,
-        human_review_reasons: synthesis.humanReviewReasons ?? [],
-        findings: (synthesis.synthesisDisplay || []).map((f) => ({
-            id: f.id ?? null,
-            category: f.category,
-            summary: f.summary,
-            detail: f.detail,
-            suggested_fix: f.agentFixPrompt ?? null,
-            source: f.source ?? null,
-            location: f.filePath || f.startLine != null || f.endLine != null
-                ? {
-                    path: f.filePath ?? null,
-                    start_line: f.startLine ?? null,
-                    end_line: f.endLine ?? null,
-                }
-                : null,
-            severity: f.severity ?? null,
-        })),
-    };
-    if (manifest) {
-        const fixed = manifest.fixedItems.length;
-        const remaining = manifest.leftForReview.length;
-        payload.fixer = {
-            status: 'completed',
-            result_sha: manifest.resultSha ?? headSha,
-            summary: `Fixed ${fixed} finding${fixed === 1 ? '' : 's'}; ${remaining} remain${remaining === 1 ? 's' : ''} for review.`,
-        };
-    }
-    return withSchema('triage', payload);
-}
-export function buildJsonState(pr, status, message) {
-    const payload = {
-        ref: `${pr.owner}/${pr.repo}#${pr.prNumber}`,
-        head_sha: null,
-        status,
-        verdict: null,
-        rating: null,
-        human_review_reasons: [],
-        findings: [],
-    };
-    if (message)
-        payload.message = message;
-    return withSchema('triage', payload);
-}
-export async function fetchTriageHeadSha(pr, token) {
-    if (!token)
-        return null;
-    const meta = await fetchGitHubJson(`/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, token);
-    const headSha = meta.head?.sha;
-    if (!headSha)
-        throw new Error('GitHub PR metadata response is missing head.sha');
-    return headSha;
-}
-function printJsonState(pr, status, message) {
-    console.log(JSON.stringify(buildJsonState(pr, status, message), null, 2));
-}
-function ratingStars(rating) {
-    const filled = '\u2605'; // ★
-    const empty = '\u2606'; // ☆
-    return filled.repeat(rating) + empty.repeat(5 - rating);
-}
-function printHookOutput(pr, synthesis, manifest, status) {
-    const label = `${pr.owner}/${pr.repo}#${pr.prNumber}`;
-    const reviewUrl = `https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}`;
-    if (status === 'pending') {
-        console.log(`[Haystack] ${label}: Analysis in progress...`);
-        return;
-    }
-    if (status === 'failed') {
-        console.log(`[Haystack] ${label}: Analysis failed`);
-        return;
-    }
-    if (status === 'stale') {
-        console.log(`[Haystack] ${label}: Stale (submitted > 2h ago)`);
-        return;
-    }
-    if (!synthesis) {
-        console.log(`[Haystack] ${label}: Analysis in progress...`);
-        return;
-    }
-    const stars = ratingStars(synthesis.haystackRating);
-    const fixingCount = manifest?.fixedItems?.length ?? 0;
-    // Only count findings the auto-fixer is NOT handling \u2014 those are what need the user.
-    const actionable = (synthesis.synthesisDisplay || []).filter((f) => !isAutoFixing(f, manifest));
-    if (actionable.length === 0 && fixingCount === 0) {
-        console.log(`[Haystack] \u2705 ${label} ${stars}: Good to merge`);
-    }
-    else if (actionable.length === 0) {
-        // Everything is being auto-fixed \u2014 nothing for the user to do.
-        console.log(`[Haystack] \u2705 ${label} ${stars}: ${fixingCount} being auto-fixed, nothing for you to do`);
-    }
-    else {
-        const parts = [`${actionable.length} finding(s)`];
-        if (fixingCount > 0)
-            parts.push(`${fixingCount} being auto-fixed`);
-        console.log(`[Haystack] \u26A0\uFE0F  ${label} ${stars}: Needs your input (${parts.join(', ')})`);
-        console.log(`  ${reviewUrl}`);
-    }
-}
-// ============================================================================
-// Waiting (event-driven with polling fallback)
-// ============================================================================
-const POLL_INTERVAL_MS = 5_000;
-const POLL_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
-/** With a live event subscription, checks are event-driven; this slow cycle
- *  is only a safety net against a silently dead socket. */
-const SUBSCRIBED_RECHECK_MS = 60_000;
-const PR_EVENTS_WS_BASE = process.env.HAYSTACK_PR_EVENTS_WS_URL ?? 'wss://haystackeditor.com/api/pr-events';
-/**
- * Subscribe to the pr-events worker for this PR — the same real-time channel
- * the web inbox uses. Any event (analysis_complete, commit_pushed, ...) calls
- * `onEvent`, and the caller re-checks analysis state immediately instead of
- * discovering it on the next poll tick. Returns null when a socket can't even
- * be constructed; connection failures after that surface via isConnected().
- */
-function subscribeToPrEvents(owner, repo, prNumber, token, onEvent, quiet) {
-    // Diagnostics are dim stderr lines, once per failure mode — polling is the
-    // designed fallback, but WHY live updates are off must stay visible (PR001).
-    // quiet (--hook) mode stays terse: the hook output is machine-parsed.
-    const diag = (msg) => {
-        if (!quiet)
-            process.stderr.write(`\n  ${chalk.dim(`[live updates unavailable: ${msg}; using polling]`)}\n`);
-    };
-    try {
-        const ws = new WebSocket(`${PR_EVENTS_WS_BASE}/${owner}/${repo}/${prNumber}/subscribe`, {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        let connected = false;
-        let reported = false;
-        ws.on('open', () => { connected = true; });
-        ws.on('message', () => onEvent());
-        ws.on('error', (err) => {
-            connected = false;
-            if (!reported) {
-                reported = true;
-                diag(err.message);
-            }
-        });
-        ws.on('close', () => { connected = false; });
-        const keepalive = setInterval(() => {
-            // A failed send means the socket died between ticks; the 'error'/'close'
-            // handlers above report it and flip isConnected() — nothing extra to say.
-            try {
-                ws.send('ping');
-            }
-            catch { /* surfaced via error/close handlers */ }
-        }, 30_000);
-        keepalive.unref?.();
-        return {
-            isConnected: () => connected,
-            close: () => {
-                clearInterval(keepalive);
-                // Idempotent teardown, not a fallback: close() on an already-dead
-                // socket can throw in ws and there is genuinely nothing to handle.
-                try {
-                    ws.close();
-                }
-                catch { /* already closed */ }
-            },
-        };
-    }
-    catch (err) {
-        diag(err instanceof Error ? err.message : String(err));
-        return null;
-    }
-}
-async function waitForAnalysis(owner, repo, prNumber, timeoutMs, token, quiet) {
-    const deadline = Date.now() + timeoutMs;
-    let consecutiveErrors = 0;
-    // Event-driven wake: a pr-events message resolves the current sleep so the
-    // re-check happens the moment analysis completes, not on the next tick.
-    let wake = null;
-    const subscription = token
-        ? subscribeToPrEvents(owner, repo, prNumber, token, () => wake?.(), quiet)
-        : null;
-    try {
-        while (Date.now() < deadline) {
-            const result = await checkAnalysisReady(owner, repo, prNumber, token);
-            if (result.status === 'ready')
-                return 'ready';
-            if (result.status === 'error') {
-                consecutiveErrors++;
-                if (consecutiveErrors >= 5)
-                    return 'error';
-            }
-            else {
-                consecutiveErrors = 0;
-            }
-            const live = subscription?.isConnected() ?? false;
-            if (!quiet) {
-                const mode = live ? 'Waiting for analysis (live)...' : 'Waiting for analysis to complete...';
-                process.stderr.write(`\r  ${chalk.dim(mode)}${'  '.repeat(5)}`);
-            }
-            const interval = Math.min(live ? SUBSCRIBED_RECHECK_MS : POLL_INTERVAL_MS, Math.max(deadline - Date.now(), 0));
-            await new Promise((resolve) => {
-                const timer = setTimeout(() => { wake = null; resolve(); }, interval);
-                timer.unref?.();
-                wake = () => { clearTimeout(timer); wake = null; resolve(); };
-            });
-        }
-        return 'pending';
-    }
-    finally {
-        subscription?.close();
-    }
-}
-// ============================================================================
-// PR resolution
-// ============================================================================
-/**
- * Resolve a PR from an explicit identifier or from pending-submit state.
- * Returns null (and handles output) if no PR can be resolved.
- */
-function resolvePR(identifier, options) {
-    if (identifier) {
-        try {
-            return parsePrRef(identifier, 'triage');
-        }
-        catch (err) {
-            console.error(chalk.red(`\n${err.message}\n`));
-            process.exit(1);
-        }
-    }
-    // No arg — read from pending state
-    const pending = loadPendingSubmit();
-    if (!pending) {
-        if (options.json) {
-            // Versioned error envelope (the old `{"status":"none"}` matched no
-            // schema); the caller asked for a triage and there is nothing to triage.
-            console.log(JSON.stringify(withSchema('error', {
-                status: 'error',
-                error: 'No pending submit to triage. Pass a PR identifier: haystack triage owner/repo#123 --json',
-            }), null, 2));
-            process.exitCode = 1;
-        }
-        else if (!options.hook) {
-            console.log(chalk.dim('No pending submits. Pass a PR number to triage a specific PR.\n'));
-        }
-        return null;
-    }
-    return { owner: pending.owner, repo: pending.repo, prNumber: pending.prNumber };
-}
-// ============================================================================
-// Main command
-// ============================================================================
-export async function triageCommand(identifier, options) {
-    // Handle --clear
-    if (options.clear) {
-        clearPendingSubmit();
-        if (options.json) {
-            // stdout stays pure JSON in --json mode; use the shared action envelope.
-            console.log(JSON.stringify(withSchema('action', {
-                action: 'clear_pending',
-                status: 'ok',
-                ref: null,
-                detail: 'Pending submit state cleared.',
-            }), null, 2));
-        }
-        else if (!options.hook) {
-            console.log(chalk.dim('Pending submit state cleared.'));
-        }
-        return;
-    }
-    // Resolve PR identifier — explicit arg or fall back to pending-submit.json
-    const pr = resolvePR(identifier, options);
-    if (!pr)
-        return;
-    const isQuiet = options.hook || options.json;
-    // Load GitHub token for private repo auth
-    let token;
-    try {
-        token = await loadToken({ owner: pr.owner, repo: pr.repo }) || undefined;
-    }
-    catch (err) {
-        if (!isQuiet) {
-            console.log(chalk.yellow(`\n⚠ Could not load Haystack credentials: ${err.message}`));
-            console.log(chalk.dim('  Continuing without GitHub auth. Private repos may require `haystack login`.\n'));
-        }
-    }
-    if (!isQuiet) {
-        console.log(chalk.dim(`\nFetching analysis for ${pr.owner}/${pr.repo}#${pr.prNumber}...`));
-    }
-    // Check if analysis is ready — resolve to a terminal state before fetching
-    let analysisReady = false;
-    const readyResult = await checkAnalysisReady(pr.owner, pr.repo, pr.prNumber, token);
-    if (readyResult.status === 'ready') {
-        analysisReady = true;
-    }
-    else if (readyResult.status === 'pending') {
-        // Hook mode: short 5s poll. --no-wait: skip. Default: full poll.
-        if (options.hook) {
-            const hookResult = await waitForAnalysis(pr.owner, pr.repo, pr.prNumber, 5_000, token, true);
-            if (hookResult === 'ready') {
-                analysisReady = true;
-            }
-            else {
-                updatePendingSubmitIfExists(pr);
-                printHookOutput(pr, null, null, 'pending');
-                return;
-            }
-        }
-        else if (options.wait === false) {
-            if (options.json) {
-                printJsonState(pr, 'pending');
-            }
-            else {
-                console.log(chalk.yellow('\n  Analysis is still in progress.'));
-                console.log(chalk.dim('  Re-run without --no-wait to poll until complete.\n'));
-            }
-            return;
-        }
-        else {
-            // Full poll
-            if (!options.json) {
-                console.log(chalk.dim('  Analysis in progress, waiting...'));
-            }
-            const waitResult = await waitForAnalysis(pr.owner, pr.repo, pr.prNumber, POLL_TIMEOUT_MS, token, options.json);
-            if (!options.json) {
-                process.stderr.write('\r' + ' '.repeat(60) + '\r');
-            }
-            if (waitResult === 'ready') {
-                analysisReady = true;
-            }
-            else if (waitResult === 'pending') {
-                if (options.json) {
-                    printJsonState(pr, 'pending', 'Timed out waiting for analysis');
-                }
-                else {
-                    console.log(chalk.yellow('\n  Timed out waiting for analysis.'));
-                    console.log(chalk.dim('  Try again later: ') + chalk.cyan(`haystack triage ${pr.owner}/${pr.repo}#${pr.prNumber}\n`));
-                }
-                return;
-            }
-            else {
-                // waitResult === 'error'
-                if (options.json) {
-                    printJsonState(pr, 'failed', 'Analysis check failed');
-                }
-                else {
-                    console.error(chalk.red('\n  Analysis check failed.\n'));
-                }
-                process.exit(1);
-            }
-        }
-    }
-    else {
-        // readyResult.status === 'error'
-        if (options.hook) {
-            printHookOutput(pr, null, null, 'failed');
-            return;
-        }
-        if (options.json) {
-            printJsonState(pr, 'failed', readyResult.message);
-        }
-        else {
-            console.error(chalk.red(`\n  Analysis check failed: ${readyResult.message}\n`));
-        }
-        process.exit(1);
-    }
-    if (!analysisReady)
-        return;
-    // Fetch the full rating synthesis and auto-fix manifest in parallel.
-    // Auth failures throw a classified error — report it as failed (with the
-    // remediation) rather than the old behavior of "not available yet, retry".
-    let synthesis;
-    let autoFixManifest;
-    let headSha;
-    try {
-        [synthesis, autoFixManifest, headSha] = await Promise.all([
-            fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token),
-            fetchAutoFixManifest(pr.owner, pr.repo, pr.prNumber, token),
-            fetchTriageHeadSha(pr, token),
-        ]);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (options.hook) {
-            // Session-start hooks must never fail the session — match the
-            // status-check error path above: print the failed line, exit 0.
-            printHookOutput(pr, null, null, 'failed');
-            return;
-        }
-        if (options.json) {
-            printJsonState(pr, 'failed', message);
-        }
-        else {
-            console.error(chalk.red(`\n  ${message}\n`));
-        }
-        process.exit(1);
-    }
-    // Update pending state if this PR matches the pending submit
-    updatePendingSubmitIfExists(pr, synthesis ? 'completed' : undefined);
-    if (!synthesis) {
-        if (options.hook) {
-            printHookOutput(pr, null, null, 'pending');
-            return;
-        }
-        if (options.json) {
-            printJsonState(pr, 'unavailable', 'Rating synthesis not available');
-        }
-        else {
-            console.error(chalk.yellow('\n  Analysis completed but rating synthesis is not available yet.'));
-            console.log(chalk.dim('  Try again in a moment, or view the full review:'));
-            console.log(chalk.cyan(`  https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}\n`));
-        }
-        process.exit(1);
-    }
-    // Output
-    if (options.hook) {
-        printHookOutput(pr, synthesis, autoFixManifest);
-    }
-    else if (options.json) {
-        console.log(JSON.stringify(buildJsonOutput(pr, headSha, synthesis, autoFixManifest), null, 2));
-    }
-    else {
-        printRichOutput(pr, synthesis, autoFixManifest);
-    }
-    // Record findings-seen marker (fire-and-forget — failure is non-fatal)
-    if (synthesis.synthesisDisplay && synthesis.synthesisDisplay.length > 0 && token) {
-        const findingKeys = synthesis.synthesisDisplay.map((f) => `${f.category}|${f.summary}`);
-        recordFindingsSeen(pr, token, findingKeys).catch((err) => {
-            // Non-blocking but logged — don't swallow silently
-            if (process.env.DEBUG) {
-                console.error(chalk.dim(`  [debug] findings-seen write failed: ${err}`));
-            }
-        });
-    }
-}
-/** Pure read path for MCP: returns a public payload without writing stdout or exiting. */
-export async function fetchTriagePayload(identifier) {
-    const pr = parsePrRef(identifier, 'triage');
-    const token = await loadToken({ owner: pr.owner, repo: pr.repo }) || undefined;
-    const ready = await checkAnalysisReady(pr.owner, pr.repo, pr.prNumber, token);
-    if (ready.status === 'pending')
-        return buildJsonState(pr, 'pending');
-    if (ready.status === 'error')
-        return buildJsonState(pr, 'failed', ready.message);
-    const [synthesis, manifest, headSha] = await Promise.all([
-        fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token),
-        fetchAutoFixManifest(pr.owner, pr.repo, pr.prNumber, token),
-        fetchTriageHeadSha(pr, token),
-    ]);
-    if (!synthesis)
-        return buildJsonState(pr, 'unavailable', 'Rating synthesis not available');
-    return buildJsonOutput(pr, headSha, synthesis, manifest);
-}
-/**
- * Update the pending-submit state if the given PR matches the pending one.
- * Best-effort — failure is silently ignored.
- */
-function updatePendingSubmitIfExists(pr, status) {
-    try {
-        const pending = loadPendingSubmit();
-        if (!pending)
-            return;
-        if (pending.owner !== pr.owner || pending.repo !== pr.repo || pending.prNumber !== pr.prNumber)
-            return;
-        if (pending.status !== 'polling')
-            return;
-        if (status === 'completed') {
-            updatePendingSubmit({
-                status: 'completed',
-                resolvedAt: new Date().toISOString(),
-            });
-        }
-    }
-    catch {
-        // Non-fatal
-    }
-}
-/**
- * Record that the user has seen analysis findings for this PR.
- * Fire-and-forget: failure is silently ignored.
- */
-async function recordFindingsSeen(pr, token, findingKeys) {
-    // Get PR head SHA
-    const ghResp = await fetch(`${githubRestBaseFor(token)}/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, {
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: 'application/vnd.github.v3+json',
-            'User-Agent': 'Haystack-CLI',
-        },
-    });
-    if (!ghResp.ok) {
-        throw new Error(`GitHub API returned ${ghResp.status}`);
-    }
-    const ghData = await ghResp.json();
-    const sha = ghData?.head?.sha;
-    if (typeof sha !== 'string' || !sha) {
-        throw new Error('Unexpected GitHub response: missing head.sha');
-    }
-    const resp = await fetch('https://haystackeditor.com/api/findings-seen', {
-        method: 'POST',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-            'User-Agent': 'Haystack-CLI',
-        },
-        body: JSON.stringify({
-            repoFullName: `${pr.owner}/${pr.repo}`,
-            prNumber: pr.prNumber,
-            commitSha: sha,
-            findingKeys,
-        }),
-    });
-    if (!resp.ok) {
-        throw new Error(`findings-seen API returned ${resp.status}`);
-    }
-}