@haystackeditor/cli 0.8.0 → 0.9.0

package/dist/commands/triage.js

@@ -0,0 +1,354 @@
+/**
+ * triage command — View Haystack analysis results for any PR.
+ *
+ * Fetches the full rating synthesis (same data shown on the Haystack feed)
+ * and displays verdict, findings, verified bugs, and agent fix prompts.
+ *
+ * Accepts a PR identifier in several formats:
+ *   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
+ */
+import chalk from 'chalk';
+import { checkAnalysisReady, fetchRatingSynthesis } from '../utils/analysis-api.js';
+import { parseRemoteUrl } from '../utils/git.js';
+import { loadToken } from './login.js';
+// ============================================================================
+// PR identifier parsing
+// ============================================================================
+/**
+ * Parse a PR identifier from various formats:
+ *   123                                    -> uses current repo
+ *   #123                                   -> uses current repo
+ *   owner/repo#123                         -> fully qualified
+ *   https://github.com/owner/repo/pull/123 -> GitHub URL
+ */
+function parsePRIdentifier(identifier) {
+    // GitHub URL: https://github.com/owner/repo/pull/123
+    const urlMatch = identifier.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/);
+    if (urlMatch) {
+        return { owner: urlMatch[1], repo: urlMatch[2], prNumber: parseInt(urlMatch[3], 10) };
+    }
+    // Fully qualified: owner/repo#123
+    const qualifiedMatch = identifier.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+    if (qualifiedMatch) {
+        return { owner: qualifiedMatch[1], repo: qualifiedMatch[2], prNumber: parseInt(qualifiedMatch[3], 10) };
+    }
+    // Bare number: 123 or #123
+    const numberMatch = identifier.match(/^#?(\d+)$/);
+    if (numberMatch) {
+        const prNumber = parseInt(numberMatch[1], 10);
+        // Infer owner/repo from git remote
+        try {
+            const remote = parseRemoteUrl('origin');
+            return { owner: remote.owner, repo: remote.repo, prNumber };
+        }
+        catch {
+            throw new Error(`Cannot determine repository for PR #${prNumber}.\n` +
+                `Use the full format: haystack triage owner/repo#${prNumber}`);
+        }
+    }
+    throw new Error(`Invalid PR identifier: "${identifier}"\n\n` +
+        `Accepted formats:\n` +
+        `  haystack triage 123\n` +
+        `  haystack triage owner/repo#123\n` +
+        `  haystack triage https://github.com/owner/repo/pull/123`);
+}
+// ============================================================================
+// Output formatting
+// ============================================================================
+function ratingLabel(rating) {
+    switch (rating) {
+        case 5: return chalk.green.bold('5/5') + chalk.green(' — Safe to merge');
+        case 4: return chalk.green('4/5') + chalk.dim(' — Low risk');
+        case 3: return chalk.yellow('3/5') + chalk.dim(' — Moderate risk');
+        case 2: return chalk.red('2/5') + chalk.dim(' — High risk');
+        case 1: return chalk.red.bold('1/5') + chalk.red(' — Critical issues');
+        default: return chalk.dim(`${rating}/5`);
+    }
+}
+function verdictLabel(verdict) {
+    switch (verdict) {
+        case 'clean': return chalk.green.bold('Clean');
+        case 'has-issues': return chalk.yellow.bold('Has Issues');
+        default: return chalk.dim('Unknown');
+    }
+}
+function severityIcon(severity) {
+    switch (severity) {
+        case 'critical': return chalk.red.bold('✗✗');
+        case 'high': return chalk.red('✗');
+        case 'medium': return chalk.yellow('!');
+        case 'low': return chalk.blue('·');
+        default: return chalk.dim('-');
+    }
+}
+function printRichOutput(pr, synthesis) {
+    const reviewUrl = `https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}`;
+    console.log(chalk.bold('\n' + '━'.repeat(60)));
+    console.log(chalk.bold(`  Haystack Analysis: ${pr.owner}/${pr.repo}#${pr.prNumber}`));
+    console.log(chalk.bold('━'.repeat(60) + '\n'));
+    // Rating & verdict
+    console.log(`  ${chalk.dim('Rating:')}   ${ratingLabel(synthesis.haystackRating)}`);
+    console.log(`  ${chalk.dim('Verdict:')}  ${verdictLabel(synthesis.analysisVerdict)}`);
+    if (synthesis.phase) {
+        const phaseLabel = synthesis.phase === 2 ? 'Final (post-verification)' : 'Preliminary (pre-verification)';
+        console.log(`  ${chalk.dim('Phase:')}    ${chalk.dim(phaseLabel)}`);
+    }
+    if (synthesis.verificationConfidence) {
+        const conf = synthesis.verificationConfidence;
+        const levelColor = conf.level === 'high' ? chalk.green : conf.level === 'medium' ? chalk.yellow : chalk.red;
+        console.log(`  ${chalk.dim('Verified:')} ${levelColor(conf.level)} — ${chalk.dim(conf.summary)}`);
+    }
+    if (synthesis.reviewRecommendation?.canAutoMerge) {
+        console.log(`  ${chalk.dim('Merge:')}    ${chalk.green('Safe to auto-merge')}`);
+    }
+    // Verification results (build/test/lint)
+    if (synthesis.verification) {
+        const v = synthesis.verification;
+        const parts = [];
+        if (v.build)
+            parts.push(v.build.success ? chalk.green('build ✓') : chalk.red('build ✗'));
+        if (v.test)
+            parts.push(v.test.success ? chalk.green('test ✓') : chalk.red('test ✗'));
+        if (v.lint)
+            parts.push(v.lint.success ? chalk.green('lint ✓') : chalk.red('lint ✗'));
+        if (parts.length > 0) {
+            console.log(`  ${chalk.dim('Checks:')}   ${parts.join('  ')}`);
+        }
+    }
+    // Findings (synthesisDisplay) — the main actionable content
+    if (synthesis.synthesisDisplay && synthesis.synthesisDisplay.length > 0) {
+        console.log(chalk.bold('\n  Findings\n'));
+        for (let i = 0; i < synthesis.synthesisDisplay.length; i++) {
+            const finding = synthesis.synthesisDisplay[i];
+            const sourceTag = finding.source ? chalk.dim(` (via ${finding.source})`) : '';
+            console.log(`  ${chalk.yellow(`${i + 1}.`)} ${chalk.bold(finding.category)}${sourceTag}`);
+            console.log(`     ${finding.summary}`);
+            if (finding.detail) {
+                // Indent multi-line detail
+                const detailLines = finding.detail.split('\n');
+                for (const line of detailLines) {
+                    console.log(`     ${chalk.dim(line)}`);
+                }
+            }
+            console.log('');
+        }
+    }
+    // Verified bugs
+    const confirmedBugs = (synthesis.verifiedBugs || []).filter(b => b.verified);
+    if (confirmedBugs.length > 0) {
+        console.log(chalk.bold('  Verified Bugs\n'));
+        for (const bug of confirmedBugs) {
+            const sourceTag = bug.source ? chalk.dim(` (via ${bug.source.type}${bug.source.author ? `: ${bug.source.author}` : ''})`) : '';
+            console.log(`  ${severityIcon(bug.assessedSeverity)} ${chalk.bold(bug.originalTitle)}${sourceTag}`);
+            console.log(`     ${chalk.dim('Severity:')} ${bug.assessedSeverity}${bug.likelihood ? `, ${bug.likelihood} occurrence` : ''}`);
+            console.log(`     ${bug.rationale}`);
+            console.log('');
+        }
+    }
+    // Human review reasons
+    if (synthesis.humanReviewReasons && synthesis.humanReviewReasons.length > 0) {
+        console.log(chalk.bold('  Human Review Required\n'));
+        for (const reason of synthesis.humanReviewReasons) {
+            const icon = reason.severity === 'high' || reason.severity === 'critical'
+                ? chalk.red('!')
+                : chalk.yellow('·');
+            console.log(`  ${icon} ${reason.reason}`);
+            if (reason.source) {
+                console.log(`     ${chalk.dim(`Source: ${reason.source}`)}`);
+            }
+        }
+        console.log('');
+    }
+    // Agent fix prompts — the key actionable output for coding agents
+    const fixableFindings = (synthesis.synthesisDisplay || []).filter(f => f.agentFixPrompt);
+    if (fixableFindings.length > 0) {
+        console.log(chalk.bold('  Agent Fix Prompts'));
+        console.log(chalk.dim('  (Copy these to your coding agent to fix the issues)\n'));
+        for (let i = 0; i < fixableFindings.length; i++) {
+            const finding = fixableFindings[i];
+            console.log(chalk.cyan(`  --- Fix ${i + 1}: ${finding.category} ---`));
+            console.log(`  ${finding.agentFixPrompt}`);
+            console.log('');
+        }
+    }
+    // Verification impact
+    if (synthesis.verificationImpact) {
+        console.log(`  ${chalk.dim('Verification impact:')} ${synthesis.verificationImpact}`);
+        console.log('');
+    }
+    console.log(`  ${chalk.dim('Full review:')} ${chalk.cyan(reviewUrl)}`);
+    console.log('');
+}
+function printJsonOutput(pr, synthesis) {
+    const reviewUrl = `https://haystackeditor.com/review/${pr.owner}/${pr.repo}/${pr.prNumber}`;
+    const output = {
+        owner: pr.owner,
+        repo: pr.repo,
+        prNumber: pr.prNumber,
+        haystackRating: synthesis.haystackRating,
+        analysisVerdict: synthesis.analysisVerdict,
+        phase: synthesis.phase,
+        canAutoMerge: synthesis.reviewRecommendation?.canAutoMerge ?? false,
+        needsHumanReview: synthesis.needsHumanReview,
+        findings: (synthesis.synthesisDisplay || []).map(f => ({
+            category: f.category,
+            summary: f.summary,
+            detail: f.detail,
+            agentFixPrompt: f.agentFixPrompt || null,
+            source: f.source || null,
+        })),
+        verifiedBugs: (synthesis.verifiedBugs || []).filter(b => b.verified).map(b => ({
+            title: b.originalTitle,
+            severity: b.assessedSeverity,
+            likelihood: b.likelihood,
+            rationale: b.rationale,
+            source: b.source || null,
+        })),
+        humanReviewReasons: synthesis.humanReviewReasons || [],
+        verification: synthesis.verification || null,
+        verificationConfidence: synthesis.verificationConfidence || null,
+        reviewUrl,
+    };
+    console.log(JSON.stringify(output, null, 2));
+}
+// ============================================================================
+// Polling
+// ============================================================================
+const POLL_INTERVAL_MS = 5_000;
+const POLL_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+async function waitForAnalysis(owner, repo, prNumber, token, quiet) {
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    let consecutiveErrors = 0;
+    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;
+        }
+        if (!quiet) {
+            process.stderr.write(`\r  ${chalk.dim('Waiting for analysis to complete...')}${'  '.repeat(5)}`);
+        }
+        await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
+    }
+    return 'pending';
+}
+// ============================================================================
+// Main command
+// ============================================================================
+export async function triageCommand(identifier, options) {
+    // Parse PR identifier
+    let pr;
+    try {
+        pr = parsePRIdentifier(identifier);
+    }
+    catch (err) {
+        console.error(chalk.red(`\n${err.message}\n`));
+        process.exit(1);
+    }
+    // Load GitHub token for private repo auth
+    const token = await loadToken() || undefined;
+    if (!options.json) {
+        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') {
+        if (options.wait === false) {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber, status: 'pending',
+                }, null, 2));
+            }
+            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;
+        }
+        // Wait for analysis
+        if (!options.json) {
+            console.log(chalk.dim('  Analysis in progress, waiting...'));
+        }
+        const waitResult = await waitForAnalysis(pr.owner, pr.repo, pr.prNumber, 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) {
+                console.log(JSON.stringify({
+                    owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber, status: 'pending',
+                }, null, 2));
+            }
+            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) {
+                console.log(JSON.stringify({
+                    owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber, status: 'error',
+                }, null, 2));
+            }
+            else {
+                console.error(chalk.red('\n  Analysis check failed.\n'));
+            }
+            process.exit(1);
+        }
+    }
+    else {
+        // readyResult.status === 'error'
+        if (options.json) {
+            console.log(JSON.stringify({
+                owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber,
+                status: 'error', message: readyResult.message,
+            }, null, 2));
+        }
+        else {
+            console.error(chalk.red(`\n  Analysis check failed: ${readyResult.message}\n`));
+        }
+        process.exit(1);
+    }
+    if (!analysisReady)
+        return;
+    // Fetch the full rating synthesis
+    const synthesis = await fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token);
+    if (!synthesis) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                owner: pr.owner, repo: pr.repo, prNumber: pr.prNumber,
+                status: 'error', message: 'Rating synthesis not available',
+            }, null, 2));
+        }
+        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.json) {
+        printJsonOutput(pr, synthesis);
+    }
+    else {
+        printRichOutput(pr, synthesis);
+    }
+}

package/dist/index.d.ts

@@ -9,6 +9,9 @@
  *   npx @haystackeditor/cli init           # Set up .haystack.json
  *   npx @haystackeditor/cli status         # Check configuration
  *   npx @haystackeditor/cli login          # Authenticate with GitHub
+ *   npx @haystackeditor/cli submit         # Create a PR (auto-merge or review)
+ *   npx @haystackeditor/cli check-pending  # Check analysis status
+ *   npx @haystackeditor/cli triage 123     # View analysis results for a PR
  *   npx @haystackeditor/cli secrets list   # List stored secrets
  */
 export {};