@haystackeditor/cli 0.9.0 → 0.10.0

package/dist/commands/pr-status.js

@@ -0,0 +1,188 @@
+/**
+ * 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.
+ *
+ * Accepts a PR identifier in several formats:
+ *   123                                    # Uses current repo's owner/repo
+ *   owner/repo#123                         # Fully qualified
+ *   https://github.com/owner/repo/pull/123 # GitHub URL
+ */
+import chalk from 'chalk';
+import { loadToken } from './login.js';
+import { parseRemoteUrl } from '../utils/git.js';
+// ============================================================================
+// PR identifier parsing
+// ============================================================================
+function parsePRIdentifier(identifier) {
+    const urlMatch = identifier.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/);
+    if (urlMatch) {
+        return { owner: urlMatch[1], repo: urlMatch[2], prNumber: parseInt(urlMatch[3], 10) };
+    }
+    const qualifiedMatch = identifier.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+    if (qualifiedMatch) {
+        return { owner: qualifiedMatch[1], repo: qualifiedMatch[2], prNumber: parseInt(qualifiedMatch[3], 10) };
+    }
+    const numberMatch = identifier.match(/^#?(\d+)$/);
+    if (numberMatch) {
+        const prNumber = parseInt(numberMatch[1], 10);
+        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 pr-status owner/repo#${prNumber}`);
+        }
+    }
+    throw new Error(`Invalid PR identifier: "${identifier}"\n\n` +
+        `Accepted formats:\n` +
+        `  haystack pr-status 123\n` +
+        `  haystack pr-status owner/repo#123\n` +
+        `  haystack pr-status https://github.com/owner/repo/pull/123`);
+}
+// ============================================================================
+// Display helpers
+// ============================================================================
+const BUCKET_DISPLAY = {
+    'analyzing': { label: 'Analyzing', color: chalk.blue, icon: '...' },
+    'auto-fixing': { label: 'Auto-fixing', 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 'clean': return chalk.green('Clean');
+        case 'has-issues': return chalk.yellow('Has issues');
+        case 'needs-review': return chalk.cyan('Needs review');
+        default: return chalk.dim(verdict ?? '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) {
+        if (response.status === 401) {
+            throw new Error('Authentication failed. Run `haystack login` to re-authenticate.');
+        }
+        if (response.status === 403) {
+            throw new Error('Access denied — you may not have permission to this repository.');
+        }
+        const body = await response.text().catch(() => '');
+        throw new Error(`API error (${response.status}): ${body}`);
+    }
+    return response.json();
+}
+// ============================================================================
+// Command
+// ============================================================================
+export async function prStatusCommand(identifier, options) {
+    let pr;
+    try {
+        pr = parsePRIdentifier(identifier);
+    }
+    catch (err) {
+        console.error(chalk.red(`\n${err.message}\n`));
+        process.exit(1);
+    }
+    const token = await loadToken();
+    if (!token) {
+        console.error(chalk.red('\nNot logged in. Run `haystack login` first.\n'));
+        process.exit(1);
+    }
+    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);
+    }
+    // JSON mode — pure JSON to stdout, nothing else
+    if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // Human-readable output
+    console.log(`  ${chalk.bold('PR')}:        ${data.prId}`);
+    console.log(`  ${chalk.bold('Status')}:    ${formatBucket(data.bucket)}`);
+    console.log(`  ${chalk.bold('Analysis')}:  ${formatAnalysisStatus(data.inputs.analysisStatus)}`);
+    if (data.inputs.analysisVerdict) {
+        console.log(`  ${chalk.bold('Verdict')}:   ${formatVerdict(data.inputs.analysisVerdict)}`);
+    }
+    if (data.inputs.haystackRating != null) {
+        console.log(`  ${chalk.bold('Rating')}:    ${data.inputs.haystackRating}/5`);
+    }
+    console.log(`  ${chalk.bold('Reason')}:    ${chalk.dim(data.reason)}`);
+    // Extra context
+    if (!data.inputs.isOpen) {
+        console.log(chalk.dim(`\n  PR is closed or merged.`));
+    }
+    if (!data.inputs.isAuthor) {
+        console.log(chalk.dim(`\n  You are not the author (author: ${data.inputs.author}).`));
+    }
+    // Labels of interest
+    const haystackLabels = (data.inputs.labels || []).filter(l => l.startsWith('haystack:'));
+    if (haystackLabels.length > 0) {
+        console.log(`  ${chalk.bold('Labels')}:    ${haystackLabels.join(', ')}`);
+    }
+    // User overrides
+    const overrides = [];
+    if (data.inputs.dismissed)
+        overrides.push('dismissed');
+    if (data.inputs.dismissedAgentAlerts)
+        overrides.push('agent alerts dismissed');
+    if (data.inputs.dismissedNeedsAssignment)
+        overrides.push('needs-assignment dismissed');
+    if (data.inputs.manuallyGoodToMerge)
+        overrides.push('manually marked good-to-merge');
+    if (data.inputs.snoozed)
+        overrides.push('snoozed');
+    if (overrides.length > 0) {
+        console.log(`  ${chalk.bold('Overrides')}: ${overrides.join(', ')}`);
+    }
+    // Stale warning
+    if (data.staleWarning) {
+        console.log(chalk.yellow(`\n  Warning: ${data.staleWarning}`));
+    }
+    console.log('');
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,13 @@
+/**
+ * haystack setup - Interactive onboarding wizard
+ *
+ * CLI equivalent of the web onboarding wizard. Walks through:
+ * 1. Login check
+ * 2. Repository selection
+ * 3. Scan for coding rules
+ * 4. Scan for wait-for signals (CI checks, bot reviews)
+ * 5. Scan for review policies
+ * 6. Review discovered items (toggle on/off)
+ * 7. Confirm & write .haystack.json to selected repos
+ */
+export declare function setupCommand(): Promise<void>;

package/dist/commands/setup.js

@@ -0,0 +1,496 @@
+/**
+ * haystack setup - Interactive onboarding wizard
+ *
+ * CLI equivalent of the web onboarding wizard. Walks through:
+ * 1. Login check
+ * 2. Repository selection
+ * 3. Scan for coding rules
+ * 4. Scan for wait-for signals (CI checks, bot reviews)
+ * 5. Scan for review policies
+ * 6. Review discovered items (toggle on/off)
+ * 7. Confirm & write .haystack.json to selected repos
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { loadToken } from './login.js';
+// =============================================================================
+// Constants
+// =============================================================================
+const HAYSTACK_API = 'https://haystackeditor.com';
+const GITHUB_API = 'https://api.github.com';
+const CATEGORY_LABELS = {
+    testing: 'Testing',
+    style: 'Style',
+    security: 'Security',
+    performance: 'Performance',
+    docs: 'Documentation',
+    other: 'Other',
+};
+const SIGNAL_TYPE_LABELS = {
+    ci_check: 'CI Check',
+    bot_review: 'Bot Review',
+    status_check: 'Status Check',
+};
+const POLICY_TYPE_LABELS = {
+    approval_count: 'Approval Count',
+    codeowner_review: 'Codeowner Review',
+    team_review: 'Team Review',
+    area_owner: 'Area Owner',
+};
+async function fetchUserRepos(token) {
+    const repos = [];
+    let page = 1;
+    // Fetch up to 200 repos (non-archived, sorted by recent push)
+    while (page <= 2) {
+        const response = await fetch(`${GITHUB_API}/user/repos?sort=pushed&per_page=100&page=${page}&type=owner`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: 'application/vnd.github.v3+json',
+                'User-Agent': 'Haystack-CLI',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch repos: ${response.status}`);
+        }
+        const batch = (await response.json());
+        if (batch.length === 0)
+            break;
+        repos.push(...batch);
+        if (batch.length < 100)
+            break;
+        page++;
+    }
+    return repos
+        .filter((r) => !r.archived)
+        .map((r) => r.full_name);
+}
+async function fetchExistingConfig(owner, repo, token) {
+    const response = await fetch(`${GITHUB_API}/repos/${owner}/${repo}/contents/.haystack.json`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/vnd.github.v3+json',
+            'User-Agent': 'Haystack-CLI',
+        },
+    });
+    if (response.status === 404)
+        return null;
+    if (!response.ok)
+        throw new Error(`Failed to fetch config: ${response.status}`);
+    const data = (await response.json());
+    const raw = Buffer.from(data.content, 'base64').toString('utf-8');
+    try {
+        return { config: JSON.parse(raw), sha: data.sha };
+    }
+    catch {
+        throw new Error('existing .haystack.json is malformed JSON — delete or fix it manually');
+    }
+}
+async function writeConfigToRepo(owner, repo, config, existingSha, token) {
+    const content = JSON.stringify(config, null, 2) + '\n';
+    const body = {
+        message: 'chore: configure Haystack via CLI setup wizard',
+        content: Buffer.from(content).toString('base64'),
+    };
+    if (existingSha)
+        body.sha = existingSha;
+    const response = await fetch(`${GITHUB_API}/repos/${owner}/${repo}/contents/.haystack.json`, {
+        method: 'PUT',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: 'application/vnd.github.v3+json',
+            'Content-Type': 'application/json',
+            'User-Agent': 'Haystack-CLI',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`Failed to write config: ${response.status} — ${err}`);
+    }
+}
+// =============================================================================
+// Merge helpers
+// =============================================================================
+/**
+ * Deep merge two plain objects. Arrays are replaced (not concatenated)
+ * since config arrays like `rules` and `wait_for` are complete sets from
+ * the wizard and should override, not append to, existing values.
+ */
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const srcVal = source[key];
+        const tgtVal = result[key];
+        if (srcVal !== null &&
+            typeof srcVal === 'object' &&
+            !Array.isArray(srcVal) &&
+            tgtVal !== null &&
+            typeof tgtVal === 'object' &&
+            !Array.isArray(tgtVal)) {
+            result[key] = deepMerge(tgtVal, srcVal);
+        }
+        else {
+            result[key] = srcVal;
+        }
+    }
+    return result;
+}
+// =============================================================================
+// Onboarding scan (SSE client)
+// =============================================================================
+async function runScan(repos, scanType, token) {
+    const response = await fetch(`${HAYSTACK_API}/api/onboarding/scan`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({ repos, scanType }),
+    });
+    if (!response.ok) {
+        throw new Error(`Scan failed: ${response.status}`);
+    }
+    return parseSseStream(response);
+}
+async function parseSseStream(response) {
+    const text = await response.text();
+    const lines = text.split('\n');
+    let items = [];
+    let eventType = '';
+    const eventDataLines = [];
+    function flushEvent() {
+        if (!eventType || eventDataLines.length === 0)
+            return;
+        const eventData = eventDataLines.join('\n');
+        const parsed = JSON.parse(eventData);
+        if (eventType === 'progress') {
+            const progress = parsed;
+            process.stdout.write(`\r${chalk.dim('  ' + progress.message)}`);
+            if (progress.detail) {
+                process.stdout.write(chalk.dim(` — ${progress.detail}`));
+            }
+            process.stdout.write('\x1b[K');
+        }
+        else if (eventType === 'result') {
+            items = parsed.items;
+        }
+        else if (eventType === 'error') {
+            throw new Error(parsed.message);
+        }
+        eventType = '';
+        eventDataLines.length = 0;
+    }
+    for (const line of lines) {
+        if (line.startsWith('event: ')) {
+            eventType = line.slice(7).trim();
+        }
+        else if (line.startsWith('data: ')) {
+            eventDataLines.push(line.slice(6));
+        }
+        else if (line === '') {
+            flushEvent();
+        }
+    }
+    // Flush any remaining buffered event at EOF (stream may not end with blank line)
+    flushEvent();
+    // Clear progress line
+    process.stdout.write('\r\x1b[K');
+    return items;
+}
+// =============================================================================
+// Display helpers
+// =============================================================================
+function printSectionHeader(title, count, total) {
+    console.log(`\n  ${chalk.bold(title)}  ${chalk.dim(`${count}/${total} enabled`)}`);
+    console.log(chalk.dim('  ' + '─'.repeat(50)));
+}
+function printRule(rule, index) {
+    const status = rule.enabled ? chalk.green('ON ') : chalk.dim('OFF');
+    const cat = chalk.dim(`[${CATEGORY_LABELS[rule.category] || rule.category}]`);
+    console.log(`  ${chalk.dim(`${index + 1}.`)} ${status} ${rule.name} ${cat}`);
+    console.log(`     ${chalk.dim(rule.description)}`);
+}
+function printSignal(signal, index) {
+    const status = signal.enabled ? chalk.green('ON ') : chalk.dim('OFF');
+    const type = chalk.dim(`[${SIGNAL_TYPE_LABELS[signal.type] || signal.type}]`);
+    console.log(`  ${chalk.dim(`${index + 1}.`)} ${status} ${signal.name} ${type}`);
+    if (signal.pattern) {
+        console.log(`     ${chalk.dim(`Pattern: ${signal.pattern}`)}`);
+    }
+}
+function printPolicy(policy, index) {
+    const status = policy.enabled ? chalk.green('ON ') : chalk.dim('OFF');
+    const type = chalk.dim(`[${POLICY_TYPE_LABELS[policy.type] || policy.type}]`);
+    console.log(`  ${chalk.dim(`${index + 1}.`)} ${status} ${policy.name} ${type}`);
+    console.log(`     ${chalk.dim(policy.description)}`);
+}
+// =============================================================================
+// Wizard steps
+// =============================================================================
+async function stepSelectRepos(token) {
+    console.log(chalk.bold('\n  Step 1: Select repositories\n'));
+    console.log(chalk.dim('  Fetching your repositories...'));
+    const repos = await fetchUserRepos(token);
+    if (repos.length === 0) {
+        console.log(chalk.yellow('\n  No repositories found.\n'));
+        process.exit(1);
+    }
+    // Clear the "Fetching" message
+    process.stdout.write('\x1b[1A\x1b[K');
+    const { selectedRepos } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selectedRepos',
+            message: 'Select repositories to configure:',
+            choices: repos.map((r) => ({ name: r, value: r })),
+            pageSize: 15,
+            validate: (answer) => {
+                if (answer.length === 0)
+                    return 'Select at least one repository.';
+                return true;
+            },
+        },
+    ]);
+    console.log(chalk.green(`  ${selectedRepos.length} repo(s) selected\n`));
+    return selectedRepos;
+}
+async function stepScan(repos, scanType, stepNum, token) {
+    const labels = {
+        rules: 'coding rules',
+        wait_for: 'CI/bot signals',
+        policies: 'review policies',
+    };
+    console.log(chalk.bold(`\n  Step ${stepNum}: Scanning for ${labels[scanType]}\n`));
+    try {
+        const items = await runScan(repos, scanType, token);
+        if (items.length === 0) {
+            console.log(chalk.dim(`  No ${labels[scanType]} discovered.`));
+        }
+        else {
+            console.log(chalk.green(`  Found ${items.length} ${labels[scanType]}`));
+        }
+        return items;
+    }
+    catch (err) {
+        console.log(chalk.yellow(`  Scan failed: ${err.message}`));
+        console.log(chalk.dim('  Skipping this scan — you can configure manually later.\n'));
+        return [];
+    }
+}
+async function stepReview(rules, signals, policies) {
+    const totalItems = rules.length + signals.length + policies.length;
+    if (totalItems === 0) {
+        console.log(chalk.dim('\n  No items discovered — skipping review.\n'));
+        return { rules, signals, policies };
+    }
+    console.log(chalk.bold('\n  Step 5: Review discovered configuration\n'));
+    console.log(chalk.dim('  Toggle items on/off. Only enabled items will be written.\n'));
+    // Show current state
+    if (rules.length > 0) {
+        printSectionHeader('Coding Rules', rules.filter((r) => r.enabled).length, rules.length);
+        rules.forEach((r, i) => printRule(r, i));
+    }
+    if (signals.length > 0) {
+        printSectionHeader('Wait-For Signals', signals.filter((s) => s.enabled).length, signals.length);
+        signals.forEach((s, i) => printSignal(s, i));
+    }
+    if (policies.length > 0) {
+        printSectionHeader('Review Policies', policies.filter((p) => p.enabled).length, policies.length);
+        policies.forEach((p, i) => printPolicy(p, i));
+    }
+    // Ask if they want to toggle anything
+    const { wantToToggle } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'wantToToggle',
+            message: 'Would you like to toggle any items?',
+            default: false,
+        },
+    ]);
+    if (wantToToggle) {
+        // Build a list of all items for toggling
+        const allItems = [];
+        if (rules.length > 0) {
+            allItems.push(new inquirer.Separator('── Coding Rules ──'));
+            rules.forEach((r) => {
+                allItems.push({
+                    name: `${r.name} ${chalk.dim(`[${CATEGORY_LABELS[r.category] || r.category}]`)}`,
+                    value: `rule:${r.id}`,
+                    checked: r.enabled,
+                });
+            });
+        }
+        if (signals.length > 0) {
+            allItems.push(new inquirer.Separator('── Wait-For Signals ──'));
+            signals.forEach((s) => {
+                allItems.push({
+                    name: `${s.name} ${chalk.dim(`[${SIGNAL_TYPE_LABELS[s.type] || s.type}]`)}`,
+                    value: `signal:${s.id}`,
+                    checked: s.enabled,
+                });
+            });
+        }
+        if (policies.length > 0) {
+            allItems.push(new inquirer.Separator('── Review Policies ──'));
+            policies.forEach((p) => {
+                allItems.push({
+                    name: `${p.name} ${chalk.dim(`[${POLICY_TYPE_LABELS[p.type] || p.type}]`)}`,
+                    value: `policy:${p.id}`,
+                    checked: p.enabled,
+                });
+            });
+        }
+        const { enabled } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'enabled',
+                message: 'Select items to enable:',
+                choices: allItems,
+                pageSize: 20,
+            },
+        ]);
+        // Apply toggling
+        rules.forEach((r) => {
+            r.enabled = enabled.includes(`rule:${r.id}`);
+        });
+        signals.forEach((s) => {
+            s.enabled = enabled.includes(`signal:${s.id}`);
+        });
+        policies.forEach((p) => {
+            p.enabled = enabled.includes(`policy:${p.id}`);
+        });
+    }
+    return { rules, signals, policies };
+}
+function buildConfig(rules, signals, policies) {
+    const config = {
+        version: 1,
+    };
+    const enabledRules = rules.filter((r) => r.enabled);
+    const enabledSignals = signals.filter((s) => s.enabled);
+    const enabledPolicies = policies.filter((p) => p.enabled);
+    if (enabledRules.length > 0) {
+        config.rules = enabledRules.map((r) => ({
+            name: r.name,
+            description: r.description,
+            category: r.category,
+        }));
+    }
+    if (enabledSignals.length > 0) {
+        config.wait_for = enabledSignals.map((s) => ({
+            name: s.name,
+            type: s.type,
+            source: s.source,
+            pattern: s.pattern,
+        }));
+    }
+    if (enabledPolicies.length > 0) {
+        config.review_policies = enabledPolicies.map((p) => ({
+            name: p.name,
+            type: p.type,
+            description: p.description,
+            config: p.config,
+        }));
+    }
+    return config;
+}
+async function stepConfirm(selectedRepos, rules, signals, policies, token) {
+    const config = buildConfig(rules, signals, policies);
+    const enabledRules = rules.filter((r) => r.enabled);
+    const enabledSignals = signals.filter((s) => s.enabled);
+    const enabledPolicies = policies.filter((p) => p.enabled);
+    const totalEnabled = enabledRules.length + enabledSignals.length + enabledPolicies.length;
+    console.log(chalk.bold('\n  Step 6: Confirm & write configuration\n'));
+    // Summary
+    const parts = [];
+    if (enabledRules.length > 0)
+        parts.push(`${enabledRules.length} rules`);
+    if (enabledSignals.length > 0)
+        parts.push(`${enabledSignals.length} signals`);
+    if (enabledPolicies.length > 0)
+        parts.push(`${enabledPolicies.length} policies`);
+    if (totalEnabled === 0) {
+        console.log(chalk.dim('  No items enabled. Config will contain version only.\n'));
+    }
+    else {
+        console.log(`  ${chalk.dim('Items:')} ${parts.join(', ')}`);
+    }
+    console.log(`  ${chalk.dim('Repos:')} ${selectedRepos.join(', ')}`);
+    // Preview
+    console.log(chalk.dim('\n  ┌─ .haystack.json ─────────────────────────────────'));
+    const preview = JSON.stringify(config, null, 2);
+    preview.split('\n').forEach((line) => {
+        console.log(chalk.dim('  │ ') + chalk.white(line));
+    });
+    console.log(chalk.dim('  └─────────────────────────────────────────────────\n'));
+    const { confirmed } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirmed',
+            message: `Write .haystack.json to ${selectedRepos.length} repo(s)?`,
+            default: true,
+        },
+    ]);
+    if (!confirmed) {
+        console.log(chalk.yellow('\n  Setup cancelled.\n'));
+        return;
+    }
+    // Write to each repo
+    const failedRepos = [];
+    for (const repoFullName of selectedRepos) {
+        const [owner, repo] = repoFullName.split('/');
+        try {
+            process.stdout.write(chalk.dim(`  Writing to ${repoFullName}...`));
+            const existing = await fetchExistingConfig(owner, repo, token);
+            const mergedConfig = existing ? deepMerge(existing.config, config) : config;
+            await writeConfigToRepo(owner, repo, mergedConfig, existing?.sha ?? null, token);
+            process.stdout.write('\r\x1b[K');
+            console.log(chalk.green(`  ✓ ${repoFullName}`));
+        }
+        catch (err) {
+            process.stdout.write('\r\x1b[K');
+            console.log(chalk.red(`  ✗ ${repoFullName}: ${err.message}`));
+            failedRepos.push(repoFullName);
+        }
+    }
+    if (failedRepos.length > 0) {
+        console.log(chalk.red(`\n  Setup failed for ${failedRepos.length} repo(s).\n`));
+        process.exit(1);
+    }
+    console.log(chalk.green('\n  Setup complete!\n'));
+}
+// =============================================================================
+// Main command
+// =============================================================================
+export async function setupCommand() {
+    console.log(chalk.cyan('\n  Haystack Setup Wizard\n'));
+    // Step 0: Check login
+    const token = await loadToken();
+    if (!token) {
+        console.log(chalk.yellow('  Not logged in. Run `haystack login` first.\n'));
+        process.exit(1);
+    }
+    // Verify token
+    const userResponse = await fetch(`${GITHUB_API}/user`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'User-Agent': 'Haystack-CLI',
+        },
+    });
+    if (!userResponse.ok) {
+        console.log(chalk.yellow('  Token expired. Run `haystack login` again.\n'));
+        process.exit(1);
+    }
+    const user = (await userResponse.json());
+    console.log(chalk.dim(`  Logged in as ${chalk.bold(user.login)}\n`));
+    // Step 1: Select repos
+    const selectedRepos = await stepSelectRepos(token);
+    // Steps 2-4: Scan for rules, wait-for signals, and review policies
+    const rules = (await stepScan(selectedRepos, 'rules', 2, token));
+    const signals = (await stepScan(selectedRepos, 'wait_for', 3, token));
+    const policies = (await stepScan(selectedRepos, 'policies', 4, token));
+    // Step 5: Review
+    const reviewed = await stepReview(rules, signals, policies);
+    // Step 6: Confirm & write
+    await stepConfirm(selectedRepos, reviewed.rules, reviewed.signals, reviewed.policies, token);
+}