@haystackeditor/cli 0.25.1 → 0.27.0

package/dist/commands/policy.js

@@ -1,371 +0,0 @@
-/**
- * haystack policy - Manage review policies
- *
- * Commands:
- *   list    - List all review policies
- *   add     - Add a new policy interactively
- *   remove  - Remove a policy by name
- *   init    - Create initial review-policy.md
- */
-import chalk from 'chalk';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { confirm as confirmPrompt, input, select } from '@inquirer/prompts';
-import { runPrompt } from '../utils/prompter.js';
-const POLICY_PATH = '.haystack/review-policy.md';
-// ============================================================================
-// Markdown Parsing
-// ============================================================================
-/**
- * Parse review-policy.md content into ReviewPolicy objects and instructions
- */
-export function parsePolicyMarkdown(content) {
-    const policies = [];
-    const instructions = [];
-    // Split by H2 headings (## )
-    const sections = content.split(/^## /m).slice(1); // Skip content before first H2
-    for (const section of sections) {
-        const lines = section.trim().split('\n');
-        if (lines.length === 0)
-            continue;
-        // First line is the section name
-        const name = lines[0].trim();
-        if (!name)
-            continue;
-        // ## Instructions — collect bullet points as raw semantic directives
-        if (name.toLowerCase() === 'instructions') {
-            for (const line of lines.slice(1)) {
-                const trimmed = line.trim();
-                const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
-                if (bulletMatch) {
-                    instructions.push(bulletMatch[1].trim());
-                }
-            }
-            continue;
-        }
-        let paths = [];
-        let severity = 'medium';
-        let reason = '';
-        // Parse fields. serializePolicies (and therefore policy init/add/remove and
-        // setup) writes them as bullets, `- **Paths**: ...`; hand-written files may
-        // omit the bullet, so accept both.
-        for (const line of lines.slice(1)) {
-            const trimmed = line.trim().replace(/^[-*]\s+/, '');
-            // Match **Paths**: `pattern1`, `pattern2`
-            const pathsMatch = trimmed.match(/^\*\*Paths?\*\*:\s*(.+)$/i);
-            if (pathsMatch) {
-                const pathString = pathsMatch[1];
-                const backtickPatterns = pathString.match(/`([^`]+)`/g);
-                if (backtickPatterns) {
-                    paths = backtickPatterns.map(p => p.replace(/`/g, '').trim());
-                }
-                else {
-                    paths = pathString.split(',').map(p => p.trim());
-                }
-                continue;
-            }
-            // Match **Severity**: critical|high|medium|low
-            const severityMatch = trimmed.match(/^\*\*Severity\*\*:\s*(critical|high|medium|low)/i);
-            if (severityMatch) {
-                severity = severityMatch[1].toLowerCase();
-                continue;
-            }
-            // Match **Reason**: ...
-            const reasonMatch = trimmed.match(/^\*\*Reason\*\*:\s*(.+)$/i);
-            if (reasonMatch) {
-                reason = reasonMatch[1].trim();
-                continue;
-            }
-        }
-        // Only add if we have at least paths and reason
-        if (paths.length > 0 && reason) {
-            policies.push({ name, paths, reason, severity });
-        }
-    }
-    return { policies, instructions };
-}
-/**
- * Serialize ReviewPolicy objects and instructions back to markdown
- */
-export function serializePolicies(policies, instructions = []) {
-    const lines = ['# Review Policies', ''];
-    if (instructions.length > 0) {
-        lines.push('## Instructions', '');
-        for (const instruction of instructions) {
-            lines.push(`- ${instruction}`);
-        }
-        lines.push('');
-    }
-    for (const policy of policies) {
-        lines.push(`## ${policy.name}`);
-        lines.push(`- **Paths**: ${policy.paths.map(p => '`' + p + '`').join(', ')}`);
-        lines.push(`- **Severity**: ${policy.severity}`);
-        lines.push(`- **Reason**: ${policy.reason}`);
-        lines.push('');
-    }
-    return lines.join('\n');
-}
-// ============================================================================
-// Severity Colors
-// ============================================================================
-function severityColor(severity) {
-    switch (severity) {
-        case 'critical': return chalk.red;
-        case 'high': return chalk.yellow;
-        case 'medium': return chalk.blue;
-        case 'low': return chalk.dim;
-        default: return chalk.white;
-    }
-}
-// ============================================================================
-// Commands
-// ============================================================================
-/**
- * List all review policies
- */
-export async function listPolicies() {
-    const filePath = join(process.cwd(), POLICY_PATH);
-    if (!existsSync(filePath)) {
-        console.log(chalk.yellow('\nNo review-policy.md found.'));
-        console.log(chalk.dim('Run "haystack policy init" to create one.\n'));
-        return;
-    }
-    const content = readFileSync(filePath, 'utf-8');
-    const { policies, instructions } = parsePolicyMarkdown(content);
-    if (policies.length === 0 && instructions.length === 0) {
-        console.log(chalk.yellow('\nNo policies or instructions defined in review-policy.md'));
-        console.log(chalk.dim('Run "haystack policy add" to create one.\n'));
-        return;
-    }
-    if (instructions.length > 0) {
-        console.log(chalk.cyan('\n📝 Review Instructions\n'));
-        for (const instruction of instructions) {
-            console.log(`  ${chalk.dim('•')} ${instruction}`);
-        }
-        console.log('');
-    }
-    if (policies.length > 0) {
-        console.log(chalk.cyan('📋 Review Policies\n'));
-        for (const policy of policies) {
-            const color = severityColor(policy.severity);
-            console.log(`  ${chalk.bold(policy.name)}`);
-            console.log(`    Severity: ${color(policy.severity)}`);
-            console.log(`    Paths: ${chalk.dim(policy.paths.join(', '))}`);
-            console.log(`    Reason: ${policy.reason}`);
-            console.log('');
-        }
-    }
-}
-/**
- * Add a new review policy interactively
- */
-export async function addPolicy(nameArg) {
-    const filePath = join(process.cwd(), POLICY_PATH);
-    // Load existing policies and instructions
-    let policies = [];
-    let instructions = [];
-    if (existsSync(filePath)) {
-        const existingContent = readFileSync(filePath, 'utf-8');
-        const parsed = parsePolicyMarkdown(existingContent);
-        policies = parsed.policies;
-        instructions = parsed.instructions;
-    }
-    // Interactive-only command: without a TTY the inquirer prompt would hang a
-    // non-interactive caller (e.g. a coding agent) forever.
-    if (!process.stdin.isTTY) {
-        console.error(chalk.red('\n`haystack policy add` is interactive and requires a terminal.\n' +
-            `Non-interactive alternative: edit ${POLICY_PATH} directly ` +
-            '(run `haystack policy list` to see the current policies and format).\n'));
-        process.exit(1);
-    }
-    console.log(chalk.cyan('\n➕ Add Review Policy\n'));
-    // Prompt for policy details
-    const answers = {
-        name: await runPrompt(input({
-            message: 'Policy name:',
-            default: nameArg,
-            validate: (value) => {
-                if (!value.trim())
-                    return 'Name is required';
-                if (policies.some(p => p.name.toLowerCase() === value.toLowerCase())) {
-                    return 'A policy with this name already exists';
-                }
-                return true;
-            },
-        })),
-        paths: await runPrompt(input({
-            message: 'File patterns (comma-separated globs):',
-            validate: (value) => value.trim() ? true : 'At least one path pattern is required',
-        })),
-        severity: await runPrompt(select({
-            message: 'Severity:',
-            choices: [
-                { name: chalk.red('critical') + ' - Always requires human review', value: 'critical' },
-                { name: chalk.yellow('high') + ' - Usually requires review', value: 'high' },
-                { name: chalk.blue('medium') + ' - Should be reviewed', value: 'medium' },
-                { name: chalk.dim('low') + ' - Nice to review', value: 'low' },
-            ],
-            default: 'medium',
-        })),
-        reason: await runPrompt(input({
-            message: 'Reason for requiring review:',
-            validate: (value) => value.trim() ? true : 'Reason is required',
-        })),
-    };
-    // Parse paths from comma-separated input
-    const paths = answers.paths.split(',').map((p) => p.trim()).filter(Boolean);
-    const newPolicy = {
-        name: answers.name.trim(),
-        paths,
-        severity: answers.severity,
-        reason: answers.reason.trim(),
-    };
-    policies.push(newPolicy);
-    // Ensure directory exists
-    const dir = dirname(filePath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    // Write updated file
-    writeFileSync(filePath, serializePolicies(policies, instructions));
-    console.log(chalk.green(`\n✓ Added policy "${newPolicy.name}"`));
-    console.log(chalk.dim(`  Updated ${POLICY_PATH}\n`));
-}
-/**
- * Remove a policy by name
- */
-export async function removePolicy(name) {
-    const filePath = join(process.cwd(), POLICY_PATH);
-    if (!existsSync(filePath)) {
-        console.log(chalk.red('\nNo review-policy.md found.\n'));
-        return;
-    }
-    const content = readFileSync(filePath, 'utf-8');
-    const parsed = parsePolicyMarkdown(content);
-    let policies = parsed.policies;
-    const instructions = parsed.instructions;
-    // Find policy (case-insensitive)
-    const index = policies.findIndex(p => p.name.toLowerCase() === name.toLowerCase());
-    if (index === -1) {
-        console.log(chalk.red(`\nPolicy "${name}" not found.\n`));
-        console.log(chalk.dim('Available policies:'));
-        for (const p of policies) {
-            console.log(chalk.dim(`  - ${p.name}`));
-        }
-        console.log('');
-        return;
-    }
-    const removed = policies[index];
-    // Confirm removal. Without a TTY the prompt would hang — the command names
-    // an exact policy, so treat the invocation itself as the confirmation.
-    if (process.stdin.isTTY) {
-        const confirm = await runPrompt(confirmPrompt({
-            message: `Remove policy "${removed.name}"?`,
-            default: false,
-        }));
-        if (!confirm) {
-            console.log(chalk.dim('\nCancelled.\n'));
-            return;
-        }
-    }
-    else {
-        console.error(chalk.dim(`No TTY — removing "${removed.name}" without interactive confirmation.`));
-    }
-    // Remove and write
-    policies = policies.filter((_, i) => i !== index);
-    writeFileSync(filePath, serializePolicies(policies, instructions));
-    console.log(chalk.green(`\n✓ Removed policy "${removed.name}"`));
-    console.log(chalk.dim(`  Updated ${POLICY_PATH}\n`));
-}
-/**
- * Add a review instruction
- */
-export async function addInstruction(text) {
-    const filePath = join(process.cwd(), POLICY_PATH);
-    // Load existing
-    let policies = [];
-    let instructions = [];
-    if (existsSync(filePath)) {
-        const content = readFileSync(filePath, 'utf-8');
-        const parsed = parsePolicyMarkdown(content);
-        policies = parsed.policies;
-        instructions = parsed.instructions;
-    }
-    let instruction = text?.trim();
-    if (!instruction) {
-        if (!process.stdin.isTTY) {
-            console.error(chalk.red('\nNo instruction text given and no terminal to prompt in.\n' +
-                'Pass the text directly: haystack policy add-instruction "Never flag weak test coverage"\n'));
-            process.exit(1);
-        }
-        const answer = await runPrompt(input({
-            message: 'Review instruction:',
-            validate: (value) => value.trim() ? true : 'Instruction text is required',
-        }));
-        instruction = answer.trim();
-    }
-    instructions.push(instruction);
-    // Ensure directory exists
-    const dir = dirname(filePath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(filePath, serializePolicies(policies, instructions));
-    console.log(chalk.green(`\n✓ Added instruction: "${instruction}"`));
-    console.log(chalk.dim(`  Updated ${POLICY_PATH}\n`));
-}
-/**
- * Create initial review-policy.md with example policies
- */
-export async function initPolicies(options) {
-    const filePath = join(process.cwd(), POLICY_PATH);
-    if (existsSync(filePath) && !options.force) {
-        console.log(chalk.yellow('\nreview-policy.md already exists. Use --force to overwrite.\n'));
-        return;
-    }
-    // Default template policies
-    const defaultPolicies = [
-        {
-            name: 'Infrastructure changes',
-            paths: ['terraform/**', '*.tf', 'pulumi/**', 'cdk/**'],
-            severity: 'high',
-            reason: 'Infrastructure changes require manual review for security and cost implications',
-        },
-        {
-            name: 'Secret files',
-            paths: ['**/*.secret*', '**/*.env*', '**/credentials*', '**/*.pem', '**/*.key'],
-            severity: 'critical',
-            reason: 'Files potentially containing secrets require security review',
-        },
-        {
-            name: 'CI/CD pipelines',
-            paths: ['.github/workflows/**', '.gitlab-ci.yml', 'Jenkinsfile', '.circleci/**'],
-            severity: 'high',
-            reason: 'CI/CD changes can affect deployment security and reliability',
-        },
-        {
-            name: 'Weak test coverage',
-            paths: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py', '**/*.go', '**/*.rs'],
-            severity: 'medium',
-            reason: 'Non-trivial logic changes without test coverage should be reviewed by a human to verify correctness',
-        },
-        {
-            name: 'Unverified agent changes',
-            paths: ['**/*'],
-            severity: 'medium',
-            reason: 'Agent-authored PRs without verification evidence (tests run, build checked, UI verified) should be reviewed by a human',
-        },
-    ];
-    // Ensure directory exists
-    const dir = dirname(filePath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(filePath, serializePolicies(defaultPolicies));
-    console.log(chalk.green(`\n✓ Created ${POLICY_PATH}`));
-    console.log(chalk.dim('\nDefault policies added:'));
-    for (const p of defaultPolicies) {
-        console.log(chalk.dim(`  - ${p.name} (${p.severity})`));
-    }
-    console.log(chalk.dim('\nEdit the file or use "haystack policy add" / "haystack policy add-instruction" to customize.\n'));
-}

package/dist/commands/pr-status.js

@@ -1,207 +0,0 @@
-/**
- * pr-status command — Show the current Haystack status of a PR.
- *
- * Calls the classify-debug endpoint to determine which inbox bucket the PR
- * is in (analyzing, auto_fixing, good_to_merge, issues, needs_assignment,
- * etc.) and displays a human-readable summary.
- *
- * `--json` emits the versioned `pr-status` schema (see `haystack schema
- * pr-status`), with all state tokens normalized to the canonical snake_case
- * vocabulary shared by every CLI JSON surface. The server's raw kebab-case
- * classify-debug response is an internal shape and is not exposed.
- *
- * Accepts a PR identifier in several formats:
- *   123                                    # Uses current repo's owner/repo
- *   #123                                   # PR number with hash
- *   owner/repo#123                         # Fully qualified
- *   https://github.com/owner/repo/pull/123 # GitHub URL
- */
-import chalk from 'chalk';
-import { resolveAuthContext } from '../utils/auth.js';
-import { classifyHttpError } from '../utils/haystack-api.js';
-import { parsePrRef } from '../utils/pr-ref.js';
-import { normalizeFeedBucket, toPublicVerdict } from '../states.js';
-import { withSchema } from '../schema.js';
-export function buildPrStatusPayload(pr, data) {
-    const inputs = data.inputs ?? {};
-    return withSchema('pr-status', {
-        ref: `${pr.owner}/${pr.repo}#${pr.prNumber}`,
-        bucket: normalizeFeedBucket(data.bucket),
-        in_feed: data.isInFeed ?? null,
-        feed_priority: data.feedPriority ?? null,
-        reason: data.reason,
-        analysis: {
-            status: inputs.analysisStatus ?? 'pending',
-            // Verdict only exists once analysis is ready; no rating-based guessing here.
-            verdict: inputs.analysisVerdict
-                ? toPublicVerdict(inputs.analysisVerdict, inputs.haystackRating)
-                : null,
-            rating: inputs.haystackRating ?? null,
-        },
-        needs_human_review: inputs.needsHumanReview ?? null,
-        labels: inputs.labels ?? [],
-        overrides: {
-            snoozed: inputs.snoozed ?? false,
-            dismissed: inputs.dismissed ?? false,
-            dismissed_agent_alerts: inputs.dismissedAgentAlerts ?? false,
-            dismissed_needs_assignment: inputs.dismissedNeedsAssignment ?? false,
-            manually_good_to_merge: inputs.manuallyGoodToMerge ?? false,
-        },
-        // The classify endpoint can return 200 with missing PR metadata (its own
-        // GitHub fetch failed) — coalesce to null so required fields never vanish
-        // from the serialized payload (undefined keys are dropped by JSON.stringify).
-        author: inputs.author ?? null,
-        is_author: inputs.isAuthor ?? null,
-        is_open: inputs.isOpen ?? null,
-        state_synced_at: data.stateSyncedAt ?? null,
-        stale_warning: data.staleWarning ?? null,
-    });
-}
-// ============================================================================
-// Display helpers
-// ============================================================================
-export const BUCKET_DISPLAY = {
-    'analyzing': { label: 'Analyzing', color: chalk.blue, icon: '...' },
-    'auto_fixing': { label: 'Auto-fixing (alpha)', color: chalk.blue, icon: '>>>' },
-    'good_to_merge': { label: 'Good to Merge', color: chalk.green, icon: '[+]' },
-    'failed_when_merging': { label: 'Failed When Merging', color: chalk.red, icon: '[!]' },
-    'issues': { label: 'Issues Found', color: chalk.yellow, icon: '[?]' },
-    'needs_assignment': { label: 'Needs Reviewer Assignment', color: chalk.yellow, icon: '[?]' },
-    'needs_shepherding': { label: 'Needs Manual Merge', color: chalk.yellow, icon: '[!]' },
-    'needs_fixing': { label: 'Agent Fixing CI', color: chalk.blue, icon: '>>>' },
-    'awaiting_review': { label: 'Awaiting Review', color: chalk.cyan, icon: '[-]' },
-    'review_requested': { label: 'Review Requested', color: chalk.cyan, icon: '[-]' },
-    'snoozed': { label: 'Snoozed', color: chalk.dim, icon: '[-]' },
-};
-function formatBucket(bucket) {
-    if (!bucket)
-        return chalk.dim('Not classified (PR may be closed, or not yet analyzed)');
-    const info = BUCKET_DISPLAY[bucket];
-    if (!info)
-        return chalk.dim(bucket);
-    return `${info.icon} ${info.color(info.label)}`;
-}
-function formatAnalysisStatus(status) {
-    switch (status) {
-        case 'ready': return chalk.green('Ready');
-        case 'in_queue': return chalk.blue('In queue');
-        case 'pending': return chalk.dim('Pending');
-        case 'error': return chalk.red('Error');
-        default: return chalk.dim(status ?? 'unknown');
-    }
-}
-function formatVerdict(verdict) {
-    switch (verdict) {
-        case 'good_to_merge': return chalk.green('Good to merge');
-        case 'needs_input': return chalk.yellow('Needs input');
-        case 'needs_review': return chalk.cyan('Needs review');
-        default: return chalk.dim('n/a');
-    }
-}
-// ============================================================================
-// API call
-// ============================================================================
-const HAYSTACK_API = 'https://haystackeditor.com';
-async function fetchClassification(owner, repo, prNumber, token) {
-    const prId = `${owner}/${repo}#${prNumber}`;
-    const response = await fetch(`${HAYSTACK_API}/auth/classify-debug?pr=${encodeURIComponent(prId)}`, {
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'User-Agent': 'Haystack-CLI',
-        },
-    });
-    if (!response.ok) {
-        throw await classifyHttpError(response, `PR status for ${prId}`);
-    }
-    return response.json();
-}
-/** Pure read path (also used by MCP): returns the versioned payload without writing stdout. */
-export async function fetchPrStatusPayload(identifier) {
-    const pr = parsePrRef(identifier, 'pr-status');
-    const authContext = await resolveAuthContext({ owner: pr.owner, repo: pr.repo });
-    const data = await fetchClassification(pr.owner, pr.repo, pr.prNumber, authContext.token);
-    return buildPrStatusPayload(pr, data);
-}
-// ============================================================================
-// Command
-// ============================================================================
-export async function prStatusCommand(identifier, options) {
-    let pr;
-    try {
-        pr = parsePrRef(identifier, 'pr-status');
-    }
-    catch (err) {
-        console.error(chalk.red(`\n${err.message}\n`));
-        process.exit(1);
-    }
-    let authContext;
-    try {
-        authContext = await resolveAuthContext({ owner: pr.owner, repo: pr.repo });
-    }
-    catch (err) {
-        console.error(chalk.red(`\n${err.message}\n`));
-        process.exit(1);
-    }
-    const token = authContext.token;
-    const prLabel = `${pr.owner}/${pr.repo}#${pr.prNumber}`;
-    if (!options.json) {
-        console.log(chalk.dim(`\nFetching status for ${prLabel}...\n`));
-    }
-    let data;
-    try {
-        data = await fetchClassification(pr.owner, pr.repo, pr.prNumber, token);
-    }
-    catch (err) {
-        console.error(chalk.red(`\n${err.message}\n`));
-        process.exit(1);
-    }
-    const payload = buildPrStatusPayload(pr, data);
-    // JSON mode — pure JSON to stdout, nothing else
-    if (options.json) {
-        console.log(JSON.stringify(payload, null, 2));
-        return;
-    }
-    // Human-readable output
-    console.log(`  ${chalk.bold('PR')}:        ${payload.ref}`);
-    console.log(`  ${chalk.bold('Status')}:    ${formatBucket(payload.bucket)}`);
-    console.log(`  ${chalk.bold('Analysis')}:  ${formatAnalysisStatus(payload.analysis.status)}`);
-    if (payload.analysis.verdict) {
-        console.log(`  ${chalk.bold('Verdict')}:   ${formatVerdict(payload.analysis.verdict)}`);
-    }
-    if (payload.analysis.rating != null) {
-        console.log(`  ${chalk.bold('Rating')}:    ${payload.analysis.rating}/5`);
-    }
-    console.log(`  ${chalk.bold('Reason')}:    ${chalk.dim(payload.reason)}`);
-    // Extra context
-    if (!payload.is_open) {
-        console.log(chalk.dim(`\n  PR is closed or merged.`));
-    }
-    if (!payload.is_author) {
-        console.log(chalk.dim(`\n  You are not the author (author: ${payload.author}).`));
-    }
-    // Labels of interest
-    const haystackLabels = payload.labels.filter(l => l.startsWith('haystack:'));
-    if (haystackLabels.length > 0) {
-        console.log(`  ${chalk.bold('Labels')}:    ${haystackLabels.join(', ')}`);
-    }
-    // User overrides
-    const overrides = [];
-    if (payload.overrides.dismissed)
-        overrides.push('dismissed');
-    if (payload.overrides.dismissed_agent_alerts)
-        overrides.push('agent alerts dismissed');
-    if (payload.overrides.dismissed_needs_assignment)
-        overrides.push('needs-assignment dismissed');
-    if (payload.overrides.manually_good_to_merge)
-        overrides.push('manually marked good-to-merge');
-    if (payload.overrides.snoozed)
-        overrides.push('snoozed');
-    if (overrides.length > 0) {
-        console.log(`  ${chalk.bold('Overrides')}: ${overrides.join(', ')}`);
-    }
-    // Stale warning
-    if (payload.stale_warning) {
-        console.log(chalk.yellow(`\n  Warning: ${payload.stale_warning}`));
-    }
-    console.log('');
-}

package/dist/commands/pr.js

@@ -1,105 +0,0 @@
-import chalk from 'chalk';
-import { loadToken } from '../utils/auth.js';
-import { fetchAutoFixManifest, fetchRatingSynthesis } from '../utils/analysis-api.js';
-import { fetchGitHubJson, haystackJson, HaystackApiError } from '../utils/haystack-api.js';
-import { parsePrRef } from '../utils/pr-ref.js';
-import { toPublicVerdict } from '../states.js';
-import { withSchema } from '../schema.js';
-export function mergePublicState(meta, entry, queueAvailable = true) {
-    if (meta.merged) {
-        return { status: 'merged', reason: 'The PR has merged.', blocking_checks: [], action: null };
-    }
-    if (meta.state === 'closed') {
-        return { status: 'closed', reason: 'The PR was closed without merging.', blocking_checks: [], action: null };
-    }
-    if (!queueAvailable) {
-        return {
-            status: 'unavailable',
-            reason: 'Haystack merge status is temporarily unavailable.',
-            blocking_checks: [],
-            action: 'Retry this request before making a merge decision.',
-        };
-    }
-    if (!entry) {
-        return {
-            status: 'not_applicable',
-            reason: 'The PR is not currently in Haystack merge processing.',
-            blocking_checks: [],
-            action: null,
-        };
-    }
-    const failed = entry.failedChecks ?? [];
-    const blocked = failed.length > 0
-        || entry.status === 'failed'
-        || entry.status === 'needs_shepherding'
-        || entry.status === 'awaiting_human_approval';
-    return {
-        status: blocked ? 'blocked' : 'processing',
-        reason: blocked ? 'The PR has merge blockers.' : 'Haystack is processing the PR.',
-        blocking_checks: failed,
-        action: blocked ? 'Resolve the merge blockers.' : null,
-    };
-}
-export async function fetchMergePublicState(meta, prNumber, owner, repo, token) {
-    try {
-        const mergeQueue = await haystackJson(`/api/merge-queue/status?repo=${encodeURIComponent(`${owner}/${repo}`)}&branch=${encodeURIComponent(meta.base.ref)}`, token);
-        return mergePublicState(meta, mergeQueue.prStatuses?.[String(prNumber)]);
-    }
-    catch (err) {
-        // Auth failures are actionable, not transient — surface them instead of
-        // reporting "temporarily unavailable, retry".
-        if (err instanceof HaystackApiError && err.isAuthError)
-            throw err;
-        return mergePublicState(meta, undefined, false);
-    }
-}
-export async function fetchPrStatePayload(ref) {
-    const pr = parsePrRef(ref, 'pr get');
-    const token = await loadToken({ owner: pr.owner, repo: pr.repo });
-    if (!token)
-        throw new Error('Not authenticated. Run `haystack login` first.');
-    const meta = await fetchGitHubJson(`/repos/${pr.owner}/${pr.repo}/pulls/${pr.prNumber}`, token);
-    const [synthesis, manifest, merge] = await Promise.all([
-        fetchRatingSynthesis(pr.owner, pr.repo, pr.prNumber, token),
-        fetchAutoFixManifest(pr.owner, pr.repo, pr.prNumber, token),
-        fetchMergePublicState(meta, pr.prNumber, pr.owner, pr.repo, token),
-    ]);
-    const payload = {
-        ref: `${pr.owner}/${pr.repo}#${pr.prNumber}`,
-        title: meta.title,
-        head_sha: meta.head.sha,
-        triage: synthesis
-            ? {
-                status: 'complete',
-                verdict: toPublicVerdict(synthesis.analysisVerdict, synthesis.haystackRating),
-                findings_count: synthesis.synthesisDisplay?.length ?? 0,
-            }
-            : { status: 'pending', verdict: null, findings_count: 0 },
-        merge,
-    };
-    if (manifest) {
-        const fixed = manifest.fixedItems.length;
-        const remaining = manifest.leftForReview.length;
-        payload.fixer = {
-            status: 'completed',
-            result_sha: manifest.resultSha ?? meta.head.sha,
-            summary: `Fixed ${fixed} finding${fixed === 1 ? '' : 's'}; ${remaining} remain${remaining === 1 ? 's' : ''} for review.`,
-        };
-    }
-    return withSchema('pr', payload);
-}
-export async function prReadCommand(ref, options) {
-    const payload = await fetchPrStatePayload(ref);
-    if (options.json) {
-        console.log(JSON.stringify(payload, null, 2));
-        return;
-    }
-    const triage = payload.triage;
-    const merge = payload.merge;
-    console.log(`\n  ${chalk.bold(String(payload.ref))}  ${chalk.dim(String(payload.title))}`);
-    console.log(`  ${chalk.dim('triage:')}  ${triage.status}${triage.verdict ? ` · ${triage.verdict}` : ''} · ${triage.findings_count} findings`);
-    console.log(`  ${chalk.dim('merge:')}   ${merge.status} · ${merge.reason}`);
-    if (merge.action)
-        console.log(`  ${chalk.dim('next:')}    ${merge.action}`);
-    console.log('');
-}