@haystackeditor/cli 0.14.6 → 0.15.1

package/dist/commands/setup.d.ts

@@ -11,4 +11,19 @@
  * 7. Confirm & write .haystack.json to selected repos
  * 8. Install session tracking (Entire CLI + .entire/settings.json + local hooks)
  */
-export declare function setupCommand(): Promise<void>;
+/**
+ * Flags accepted by `haystack setup`. With none, it runs the interactive TTY
+ * wizard. `--json` switches to the coding-agent protocol (NDJSON on stdout,
+ * answers on stdin). Any pre-supplied answer (a flag or --answers entry) skips
+ * the matching prompt, so the same flow runs fully autonomously when every
+ * decision is known up-front.
+ */
+export interface SetupOptions {
+    json?: boolean;
+    repos?: string[];
+    yes?: boolean;
+    autoMerge?: boolean;
+    skipEntire?: boolean;
+    answersFile?: string;
+}
+export declare function setupCommand(options?: SetupOptions): Promise<void>;

package/dist/commands/setup.js

@@ -12,7 +12,6 @@
  * 8. Install session tracking (Entire CLI + .entire/settings.json + local hooks)
  */
 import chalk from 'chalk';
-import inquirer from 'inquirer';
 import { execFileSync, execSync } from 'child_process';
 import { mkdirSync } from 'fs';
 import { basename, join } from 'path';
@@ -20,6 +19,41 @@ import { resolveAuthContext } from '../utils/auth.js';
 import { hooksInstall } from './hooks.js';
 import { findGitRoot } from '../utils/hooks.js';
 import { trackError, trackSetupEvent } from '../utils/telemetry.js';
+import { createPrompter, loadAnswersFile } from '../utils/prompter.js';
+/** The active prompter for this `setup` invocation (TTY or JSON). */
+let ui;
+/**
+ * Translate CLI flags into a pre-supplied answer map keyed by question id.
+ * Explicit flags win; `--answers` fills the rest. Anything still missing is
+ * asked at runtime (TTY prompt or JSON `question` event).
+ */
+function buildAnswerMap(options) {
+    const answers = options.answersFile ? loadAnswersFile(options.answersFile) : {};
+    if (options.repos && options.repos.length > 0)
+        answers.select_repos = options.repos;
+    if (typeof options.autoMerge === 'boolean')
+        answers.auto_merge = options.autoMerge;
+    if (options.skipEntire) {
+        answers.install_entire = false;
+        answers.upgrade_entire = false;
+        answers.install_hooks = false;
+    }
+    if (options.yes) {
+        // Accept defaults non-interactively: don't open the toggle UI (keep every
+        // discovered item) and confirm the write. Only fill ids not already set.
+        if (!('want_to_toggle' in answers))
+            answers.want_to_toggle = false;
+        if (!('confirm_write' in answers))
+            answers.confirm_write = true;
+        if (!('auto_merge' in answers))
+            answers.auto_merge = true;
+        if (!('install_entire' in answers))
+            answers.install_entire = false;
+        if (!('install_hooks' in answers))
+            answers.install_hooks = false;
+    }
+    return answers;
+}
 // =============================================================================
 // Constants
 // =============================================================================
@@ -310,12 +344,16 @@ async function buildEntireSettingsContent(repoFullName, token) {
         return null;
     return { content: updatedContent, existingSha };
 }
-async function addBootstrapLabels(owner, repo, prNumber, prUrl, token) {
-    // CRITICAL, not best-effort: without BOTH labels the worker's bootstrap
-    // merge path never discovers the PR and it sits open forever. The label
-    // API failing is almost always transient, so retry a few times before
-    // giving up.
-    const labels = [AUTO_MERGE_LABEL, ONBOARDING_BOOTSTRAP_LABEL];
+async function addBootstrapLabels(owner, repo, prNumber, prUrl, token, autoMerge) {
+    // CRITICAL, not best-effort. ONBOARDING_BOOTSTRAP_LABEL is the identity marker
+    // that keeps the PR recognized in the user's Analyzing / Good to Merge tabs
+    // (isOnboardingBootstrapPR) and lets the worker's bootstrap path discover it —
+    // so it's ALWAYS applied. AUTO_MERGE_LABEL enrolls the PR for auto-merge, so add
+    // it only when auto-merge is on. The label API failing is almost always
+    // transient, so retry a few times before giving up.
+    const labels = autoMerge
+        ? [ONBOARDING_BOOTSTRAP_LABEL, AUTO_MERGE_LABEL]
+        : [ONBOARDING_BOOTSTRAP_LABEL];
     let lastErr = '';
     for (let attempt = 1; attempt <= 3; attempt++) {
         const res = await fetch(`${GITHUB_PROXY}/repos/${owner}/${repo}/issues/${prNumber}/labels`, {
@@ -444,14 +482,11 @@ async function openBootstrapConfigPR(owner, repo, configFiles, token, defaultBra
     const commitSha = await createCommitWithFiles(owner, repo, baseSha, files, CONFIG_COMMIT_MSG, token);
     await createBranch(owner, repo, branchName, commitSha, token);
     const pr = await createBootstrapPR(owner, repo, branchName, defaultBranch, token, autoMergeEnabled);
-    // Only enroll the PR for auto-merge when the repo hasn't opted out. Applying
-    // the labels on an auto-merge-disabled repo would force-merge a config PR the
-    // user wants to review themselves (e.g. a repo set auto-merge-off via the web
-    // wizard, then re-run through `haystack setup`). Without labels the worker
-    // never picks it up; the PR is still opened and analyzed, it just waits.
-    if (autoMergeEnabled) {
-        await addBootstrapLabels(owner, repo, pr.number, pr.html_url, token);
-    }
+    // Always apply the onboarding-bootstrap marker so the PR stays recognized in
+    // the user's tabs (isOnboardingBootstrapPR); enroll for auto-merge only when
+    // the repo hasn't opted out. With auto-merge off the PR is still opened, marked,
+    // and analyzed — it just waits for the user to merge it.
+    await addBootstrapLabels(owner, repo, pr.number, pr.html_url, token, autoMergeEnabled);
     return { prUrl: pr.html_url, entireSettingsBundled };
 }
 /**
@@ -551,7 +586,7 @@ async function runUnifiedScan(repo, token) {
         }
         if (statusResp.status === 404) {
             // State expired (TTL) or runId never registered — surface, don't hang.
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             throw new Error('Scan state expired — please retry.');
         }
         if (!statusResp.ok) {
@@ -570,14 +605,11 @@ async function runUnifiedScan(repo, token) {
             const key = `${state.progress.message}|${state.progress.detail ?? ''}`;
             if (key !== lastProgressKey) {
                 lastProgressKey = key;
-                process.stdout.write(`\r${chalk.dim('  ' + state.progress.message)}`);
-                if (state.progress.detail)
-                    process.stdout.write(chalk.dim(` — ${state.progress.detail}`));
-                process.stdout.write('\x1b[K');
+                ui.progress(state.progress.message, state.progress.detail);
             }
         }
         if (state.status === 'done') {
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             if (!state.result)
                 throw new Error('Scan completed but returned no result.');
             return {
@@ -587,11 +619,11 @@ async function runUnifiedScan(repo, token) {
             };
         }
         if (state.status === 'error') {
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             throw new Error(state.error || 'Scan failed');
         }
         if (state.status === 'running' && Date.now() - state.updatedAt > SCAN_STALE_MS) {
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             throw new Error('Scan stalled (no progress) — please retry.');
         }
     }
@@ -694,16 +726,24 @@ function tryOpenBrowser(url) {
         return false;
     }
 }
+/** True if the App is installed; tolerates transient errors (returns false so
+ *  the poll keeps waiting) but rethrows a genuine auth failure so the caller can
+ *  bail and prompt re-auth. */
+async function isAppInstalled(token) {
+    return (await fetchHaystackInstallations(token)).length > 0;
+}
 async function stepEnsureAppInstalled(token) {
     console.log(chalk.bold('  Step 0: Verify GitHub App'));
-    let installed;
+    // Initial check — distinguish a genuine auth failure (bail, prompt re-auth)
+    // from a transient probe error (refuse-to-fail and proceed).
     try {
-        installed = await fetchHaystackInstallations(token);
+        if (await isAppInstalled(token)) {
+            console.log(chalk.green('  ✓ Haystack App installed\n'));
+            return;
+        }
     }
     catch (err) {
         if (err instanceof InstallationsAuthError) {
-            // Token is dead — retrying won't help. Prompt re-auth and exit so the
-            // user doesn't waste a 10-minute poll on something that will never work.
             console.log(chalk.yellow(`\n  Your GitHub token is no longer valid (${err.status}).`));
             console.log(chalk.dim('  Run `haystack login` to re-authenticate, then re-run `haystack setup`.\n'));
             trackError('haystack_setup_installations_auth_failure', { status: err.status });
@@ -711,81 +751,47 @@ async function stepEnsureAppInstalled(token) {
         }
         console.log(chalk.yellow(`  Could not check App installations: ${err.message}`));
         console.log(chalk.dim(`  Continuing — install manually at ${HAYSTACK_APP_INSTALL_URL} if not yet installed.\n`));
-        // Probe failed but we proceed (refuse-to-fail UX so a transient blip can't
-        // brick setup). Still log so we can see if probes start failing
-        // systemically across users.
-        trackError('haystack_setup_installations_probe_failed', {
-            error_message: err.message,
-        });
-        return;
-    }
-    if (installed.length > 0) {
-        const accounts = installed.map((i) => i.account?.login).filter(Boolean).join(', ');
-        console.log(chalk.green(`  ✓ Haystack App installed${accounts ? ` (${accounts})` : ''}\n`));
+        trackError('haystack_setup_installations_probe_failed', { error_message: err.message });
         return;
     }
     console.log(chalk.yellow('  The Haystack GitHub App is not installed yet.'));
-    console.log(chalk.dim('  Without it, Haystack can\'t analyze, triage, or merge your PRs.'));
-    console.log('');
-    console.log(`  Install at: ${chalk.cyan(HAYSTACK_APP_INSTALL_URL)}`);
-    const opened = tryOpenBrowser(HAYSTACK_APP_INSTALL_URL);
-    if (opened) {
-        console.log(chalk.dim('  (Opened in your browser. Pick the repos to grant access.)'));
+    console.log(chalk.dim("  Without it, Haystack can't analyze, triage, or merge your PRs."));
+    // Only auto-open a browser for a local interactive user. Under a coding agent
+    // (JSON mode) the `action` event carries the URL for the agent to relay.
+    if (ui.interactive) {
+        const opened = tryOpenBrowser(HAYSTACK_APP_INSTALL_URL);
+        if (opened)
+            console.log(chalk.dim('  (Opened in your browser. Pick the repos to grant access.)'));
+    }
+    // ui.action emits an `action` event (JSON) or prints + spins (TTY), then polls
+    // until the App is detected or it times out. A mid-poll auth failure surfaces
+    // as a thrown InstallationsAuthError.
+    let installed = false;
+    try {
+        installed = await ui.action({
+            id: 'install_app',
+            message: 'Install the Haystack GitHub App, then it is detected automatically.',
+            url: HAYSTACK_APP_INSTALL_URL,
+            check: () => isAppInstalled(token),
+            pollIntervalMs: APP_INSTALL_POLL_INTERVAL_MS,
+            timeoutMs: APP_INSTALL_TIMEOUT_MS,
+        });
     }
-    console.log('');
-    console.log(chalk.dim('  Waiting for install to complete...'));
-    const startedAt = Date.now();
-    let consecutiveFailures = 0;
-    let lastError = null;
-    while (Date.now() - startedAt < APP_INSTALL_TIMEOUT_MS) {
-        await new Promise((resolve) => setTimeout(resolve, APP_INSTALL_POLL_INTERVAL_MS));
-        let current;
-        try {
-            current = await fetchHaystackInstallations(token);
-            consecutiveFailures = 0;
-            lastError = null;
-        }
-        catch (err) {
-            // Auth errors during the poll loop mean the token went bad mid-flow
-            // (e.g. user revoked it from GitHub settings). Same response as the
-            // initial check — bail with re-auth guidance instead of grinding for
-            // 10 minutes against a permanent failure.
-            if (err instanceof InstallationsAuthError) {
-                console.log(chalk.yellow(`\n  Your GitHub token became invalid (${err.status}) while waiting.`));
-                console.log(chalk.dim('  Run `haystack login` to re-authenticate, then re-run `haystack setup`.\n'));
-                trackError('haystack_setup_installations_auth_failure', { status: err.status, during: 'poll' });
-                process.exit(1);
-            }
-            // Per-tick failures are usually transient (token refresh race, brief
-            // GitHub API blip). Log the first one quietly so the user sees we're
-            // not silently spinning, but don't spam the terminal every 3s.
-            consecutiveFailures += 1;
-            lastError = err instanceof Error ? err.message : String(err);
-            if (consecutiveFailures === 1) {
-                console.log(chalk.dim(`  (Transient error checking installations: ${lastError} — retrying...)`));
-            }
-            continue;
-        }
-        if (current.length > 0) {
-            const accounts = current.map((i) => i.account?.login).filter(Boolean).join(', ');
-            console.log(chalk.green(`\n  ✓ App installed${accounts ? ` (${accounts})` : ''}\n`));
-            return;
+    catch (err) {
+        if (err instanceof InstallationsAuthError) {
+            console.log(chalk.yellow(`\n  Your GitHub token became invalid (${err.status}) while waiting.`));
+            console.log(chalk.dim('  Run `haystack login` to re-authenticate, then re-run `haystack setup`.\n'));
+            trackError('haystack_setup_installations_auth_failure', { status: err.status, during: 'poll' });
+            process.exit(1);
         }
+        throw err;
     }
-    // Timeout is a real failure — emit a structured telemetry event so we can
-    // route it to ops alerting (Slack via the existing trackError → PostHog
-    // pipeline). Include whether the polling itself was failing (lastError
-    // non-null after the final tick) so we can tell "user didn't click install"
-    // apart from "GitHub API was down."
-    trackError('haystack_setup_app_install_timeout', {
-        consecutive_failures: consecutiveFailures,
-        last_error: lastError,
-        timeout_ms: APP_INSTALL_TIMEOUT_MS,
-    });
-    console.log(chalk.yellow('\n  Timed out waiting for App install.'));
-    if (lastError) {
-        console.log(chalk.dim(`  Last error checking installations: ${lastError}`));
+    if (installed) {
+        console.log(chalk.green('\n  ✓ App installed\n'));
+        return;
     }
+    trackError('haystack_setup_app_install_timeout', { timeout_ms: APP_INSTALL_TIMEOUT_MS });
+    console.log(chalk.yellow('\n  Timed out waiting for App install.'));
     console.log(chalk.dim(`  Install at ${HAYSTACK_APP_INSTALL_URL}, then re-run \`haystack setup\`.\n`));
     process.exit(1);
 }
@@ -797,22 +803,15 @@ async function stepSelectRepos(token) {
         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;
-            },
-        },
-    ]);
+    const selectedRepos = await ui.multiselect({
+        id: 'select_repos',
+        message: 'Select repositories to configure:',
+        choices: repos.map((r) => ({ name: r, value: r })),
+    });
+    if (selectedRepos.length === 0) {
+        console.log(chalk.yellow('\n  No repositories selected.\n'));
+        process.exit(1);
+    }
     console.log(chalk.green(`  ${selectedRepos.length} repo(s) selected\n`));
     return selectedRepos;
 }
@@ -886,14 +885,11 @@ async function stepReview(byRepo) {
             result.instructions.forEach((ins, i) => printInstruction(ins, i));
         }
     }
-    const { wantToToggle } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'wantToToggle',
-            message: 'Would you like to toggle any items?',
-            default: false,
-        },
-    ]);
+    const wantToToggle = await ui.confirm({
+        id: 'want_to_toggle',
+        message: 'Would you like to toggle any items?',
+        default: false,
+    });
     if (!wantToToggle)
         return;
     // NUL separates repo / kind / id in the checkbox value so it can't collide
@@ -903,7 +899,7 @@ async function stepReview(byRepo) {
     for (const [repo, result] of byRepo) {
         if (result.rules.length + result.policies.length + result.instructions.length === 0)
             continue;
-        allItems.push(new inquirer.Separator(`── ${repo} ──`));
+        allItems.push({ separator: `── ${repo} ──` });
         result.rules.forEach((r) => {
             allItems.push({
                 name: `${r.name} ${chalk.dim(`[rule · ${CATEGORY_LABELS[r.category] || r.category}]`)}`,
@@ -926,15 +922,11 @@ async function stepReview(byRepo) {
             });
         });
     }
-    const { enabled } = await inquirer.prompt([
-        {
-            type: 'checkbox',
-            name: 'enabled',
-            message: 'Select items to enable:',
-            choices: allItems,
-            pageSize: 20,
-        },
-    ]);
+    const enabled = await ui.multiselect({
+        id: 'review_enabled_items',
+        message: 'Select items to enable:',
+        choices: allItems,
+    });
     const enabledSet = new Set(enabled);
     for (const [repo, result] of byRepo) {
         result.rules.forEach((r) => { r.enabled = enabledSet.has(`${repo}${SEP}rule${SEP}${r.id}`); });
@@ -1090,22 +1082,16 @@ async function stepConfirm(byRepo, token) {
     // + the repo-level preferences.auto_merge opt-in model). When off, the
     // bootstrap PR is opened but NOT labeled, so the user merges it manually and
     // no PRs auto-merge.
-    const { autoMerge } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'autoMerge',
-            message: 'Enable auto-merge? (Haystack merges PRs automatically once they pass review)',
-            default: true,
-        },
-    ]);
-    const { confirmed } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'confirmed',
-            message: `Write Haystack config to ${selectedRepos.length} repo(s)?`,
-            default: true,
-        },
-    ]);
+    const autoMerge = await ui.confirm({
+        id: 'auto_merge',
+        message: 'Enable auto-merge? (Haystack merges PRs automatically once they pass review)',
+        default: true,
+    });
+    const confirmed = await ui.confirm({
+        id: 'confirm_write',
+        message: `Write Haystack config to ${selectedRepos.length} repo(s)?`,
+        default: true,
+    });
     if (!confirmed) {
         console.log(chalk.yellow('\n  Setup cancelled.\n'));
         return { confirmed: false, bootstrapPRs: new Map() };
@@ -1117,9 +1103,9 @@ async function stepConfirm(byRepo, token) {
         const result = byRepo.get(repoFullName);
         const files = buildOnboardingFiles(result, autoMerge);
         try {
-            process.stdout.write(chalk.dim(`  Writing to ${repoFullName}...`));
+            ui.progress(`Writing to ${repoFullName}...`);
             const writeResult = await writeOnboardingFilesToRepo(owner, repo, files, autoMerge, token);
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             if (writeResult.bootstrapPR) {
                 // Default branch was protected — config landed in a bootstrap PR. With
                 // auto-merge on, Haystack merges it once its labels are processed; with
@@ -1137,7 +1123,7 @@ async function stepConfirm(byRepo, token) {
             }
         }
         catch (err) {
-            process.stdout.write('\r\x1b[K');
+            ui.clearProgress();
             console.log(chalk.red(`  ✗ ${repoFullName}: ${err.message}`));
             failedRepos.push(repoFullName);
         }
@@ -1152,7 +1138,18 @@ async function stepConfirm(byRepo, token) {
 // =============================================================================
 // Main command
 // =============================================================================
-export async function setupCommand() {
+export async function setupCommand(options = {}) {
+    // Create the prompter FIRST: in JSON mode it redirects console.* to stderr so
+    // stdout carries only NDJSON, which the steps below rely on.
+    ui = createPrompter({ json: options.json, answers: buildAnswerMap(options) });
+    try {
+        await runSetupFlow(options);
+    }
+    finally {
+        ui.close();
+    }
+}
+async function runSetupFlow(options) {
     console.log(chalk.cyan('\n  Haystack Setup Wizard\n'));
     // Step 0: Check login
     let authContext;
@@ -1189,12 +1186,27 @@ export async function setupCommand() {
     await stepReview(byRepo);
     // Step 4: Confirm & write the config files
     const { confirmed, bootstrapPRs } = await stepConfirm(byRepo, token);
-    if (!confirmed)
+    if (!confirmed) {
+        ui.result({ status: 'cancelled' });
         return;
+    }
     // Step 7: Install Entire CLI (session tracking). bootstrapPRs tells it
     // which repos had a protected default branch so it can commit
     // .entire/settings.json to the same PR instead of a doomed direct PUT.
-    await stepInstallEntire(selectedRepos, token, bootstrapPRs);
+    // --skip-entire skips the whole step (binary install, hooks, AND the remote
+    // .entire/settings.json write) — not just the install prompt.
+    if (options.skipEntire) {
+        console.log(chalk.dim('  Skipping session tracking (--skip-entire).\n'));
+    }
+    else {
+        await stepInstallEntire(selectedRepos, token, bootstrapPRs);
+    }
+    // Final structured outcome for non-interactive/agent callers.
+    ui.result({
+        status: 'complete',
+        repos: selectedRepos,
+        pullRequests: [...bootstrapPRs.entries()].map(([repo, pr]) => ({ repo, url: pr.prUrl })),
+    });
 }
 // =============================================================================
 // Step 7: Install Entire CLI for session tracking
@@ -1337,14 +1349,11 @@ async function stepInstallEntire(selectedRepos, token, bootstrapPRs) {
     }
     else if (status.installed) {
         console.log(chalk.dim(`  Stock Entire CLI detected: ${status.version.split('\n')[0]}`));
-        const { upgrade } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'upgrade',
-                message: 'Upgrade to Haystack fork? (adds transcript optimization — saves GB of git storage)',
-                default: true,
-            },
-        ]);
+        const upgrade = await ui.confirm({
+            id: 'upgrade_entire',
+            message: 'Upgrade to Haystack fork? (adds transcript optimization — saves GB of git storage)',
+            default: true,
+        });
         if (upgrade) {
             binaryReady = await installEntireBinary();
         }
@@ -1353,14 +1362,11 @@ async function stepInstallEntire(selectedRepos, token, bootstrapPRs) {
         }
     }
     else {
-        const { install } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'install',
-                message: 'Install Entire CLI? (tracks AI coding sessions for analysis)',
-                default: true,
-            },
-        ]);
+        const install = await ui.confirm({
+            id: 'install_entire',
+            message: 'Install Entire CLI? (tracks AI coding sessions for analysis)',
+            default: true,
+        });
         if (install) {
             binaryReady = await installEntireBinary();
         }
@@ -1399,14 +1405,14 @@ async function stepInstallEntire(selectedRepos, token, bootstrapPRs) {
                 continue;
             }
             try {
-                process.stdout.write(chalk.dim(`  Configuring ${repoFullName}...`));
+                ui.progress(`Configuring ${repoFullName}...`);
                 await configureEntireSettingsViaAPI(repoFullName, token);
-                process.stdout.write('\r\x1b[K');
+                ui.clearProgress();
                 console.log(chalk.green(`  ✓ ${repoFullName}`));
                 configured++;
             }
             catch (err) {
-                process.stdout.write('\r\x1b[K');
+                ui.clearProgress();
                 console.log(chalk.yellow(`  ⚠ ${repoFullName}: ${err instanceof Error ? err.message : err}`));
             }
         }
@@ -1429,14 +1435,11 @@ async function stepInstallEntire(selectedRepos, token, bootstrapPRs) {
         });
         if (repoName) {
             try {
-                const { installHooks } = await inquirer.prompt([
-                    {
-                        type: 'confirm',
-                        name: 'installHooks',
-                        message: `Install git hooks locally for ${repoName}? (agent detection, truncation checking, LLM rules)`,
-                        default: true,
-                    },
-                ]);
+                const installHooks = await ui.confirm({
+                    id: 'install_hooks',
+                    message: `Install git hooks locally for ${repoName}? (agent detection, truncation checking, LLM rules)`,
+                    default: true,
+                });
                 if (installHooks) {
                     console.log('');
                     await hooksInstall({ skipEntire: true, force: true });

package/dist/index.js

@@ -74,23 +74,48 @@ CI signals, and review policies.
     .action(initCommand);
 program
     .command('setup')
-    .description('Interactive onboarding wizard — scan repos for rules, signals, and policies')
+    .description('Onboarding wizard — scan repos for rules/policies and write Haystack config')
+    .option('--json', 'Agent mode: emit NDJSON events on stdout, read answers on stdin (no TTY prompts)')
+    .option('--repo <repo...>', 'Repo(s) to configure (owner/name); skips the repo picker')
+    .option('-y, --yes', 'Accept defaults non-interactively (keep all discovered items, confirm write)')
+    // Defining --no-auto-merge also accepts --auto-merge; default is "ask" unless
+    // one is explicitly passed (detected via getOptionValueSource below).
+    .option('--no-auto-merge', 'Set auto-merge in the written config (--auto-merge / --no-auto-merge; omit to be asked)')
+    .option('--skip-entire', 'Skip the Entire CLI / git-hooks (session tracking) step')
+    .option('--answers <file>', 'JSON file of {questionId: value} pre-supplied answers')
     .addHelpText('after', `
-This walks you through Haystack setup step by step:
+Steps: verify GitHub App → select repos → scan (rules/policies/instructions) →
+review → write .haystack/pr-rules.yml + review-policy.md + .haystack.json.
 
-  1. Select GitHub repositories to configure
-  2. Scan for coding rules (conventions your team follows)
-  3. Scan for CI/bot signals (checks to wait for before merging)
-  4. Scan for review policies (who should review what)
-  5. Review and toggle discovered items
-  6. Write .haystack.json to your repos
+Three ways to run:
+  • Interactive (default): prompts in your terminal.
+  • Autonomous/CI: supply every decision via flags, e.g.
+      haystack setup --repo owner/name --yes --no-auto-merge --skip-entire
+  • Coding agent: --json speaks NDJSON on stdout and reads answers on stdin, so an
+    agent can auto-answer or relay questions to the user. Pre-supplied answers
+    (flags / --answers) skip the matching question.
 
 Requires authentication — run \`haystack login\` first.
 
 Examples:
   haystack setup
+  haystack setup --repo owner/name --yes
+  haystack setup --json --repo owner/name
 `)
-    .action(setupCommand);
+    .action((options, command) => {
+    // Tri-state auto-merge: undefined (ask) unless --auto-merge/--no-auto-merge
+    // was explicitly passed. commander defaults autoMerge to true because of the
+    // --no- form, so check the value source rather than the value.
+    const autoMergeExplicit = command.getOptionValueSource('autoMerge') === 'cli';
+    return setupCommand({
+        json: options.json,
+        repos: options.repo,
+        yes: options.yes,
+        autoMerge: autoMergeExplicit ? options.autoMerge : undefined,
+        skipEntire: options.skipEntire,
+        answersFile: options.answers,
+    });
+});
 program
     .command('status')
     .description('Check if .haystack.json exists and is valid')

package/dist/utils/prompter.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Prompter — decouples a wizard's *decisions* from *how they're answered*.
+ *
+ * `haystack setup` historically welded every decision to inquirer/TTY, so it
+ * couldn't run headless, in CI, or under a coding agent. The Prompter is the
+ * seam: step code calls `confirm` / `multiselect` / `action`, and the
+ * implementation decides how to source the answer.
+ *
+ * Three modes, one mechanism:
+ *   - TtyPrompter  — humans in a terminal (inquirer). Default.
+ *   - JsonPrompter — a coding agent: NDJSON events on stdout, answers on stdin.
+ *                    The agent can relay a `question` to the user OR auto-answer.
+ *   - Pre-supplied answers (flags / --answers file) short-circuit any question
+ *     by id, so the same code runs fully autonomously when every answer is known.
+ *
+ * Human-facing chrome stays as `console.*`; in JSON mode the JsonPrompter
+ * redirects `console.*` to stderr so stdout carries only NDJSON.
+ */
+/** A selectable option. A `{ separator }` entry renders a non-selectable group
+ *  header in TTY mode and is ignored in JSON mode. */
+export type Choice<T> = {
+    name: string;
+    value: T;
+    checked?: boolean;
+} | {
+    separator: string;
+};
+export interface Prompter {
+    /** True for the human TTY prompter — gates side effects like opening a browser
+     *  that only make sense for a local interactive user. */
+    readonly interactive: boolean;
+    /** Yes/no decision. */
+    confirm(q: {
+        id: string;
+        message: string;
+        default?: boolean;
+    }): Promise<boolean>;
+    /** Pick zero-or-more values. Items default-checked via `checked: true`. */
+    multiselect<T>(q: {
+        id: string;
+        message: string;
+        choices: Choice<T>[];
+    }): Promise<T[]>;
+    /**
+     * An action the user must take out-of-band (e.g. install the GitHub App).
+     * Polls `check()` until it returns true (satisfied) or `timeoutMs` elapses.
+     * A pre-supplied / stdin answer of "skip" resolves false without polling.
+     * Returns true when satisfied, false when skipped or timed out.
+     */
+    action(q: {
+        id: string;
+        message: string;
+        url?: string;
+        check: () => Promise<boolean>;
+        pollIntervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<boolean>;
+    /** Transient progress line (scan ticker, per-repo write status). */
+    progress(message: string, detail?: string): void;
+    /** Clear the current progress line. */
+    clearProgress(): void;
+    /** Final structured outcome (emitted as a `result` event in JSON mode). */
+    result(data: Record<string, unknown>): void;
+    /** Release stdin/readline so the process can exit. */
+    close(): void;
+}
+/** Answers known up-front (from flags or an --answers file), keyed by question id. */
+export type AnswerMap = Record<string, unknown>;
+export declare function loadAnswersFile(path: string): AnswerMap;
+export interface PrompterOptions {
+    json?: boolean;
+    answers?: AnswerMap;
+}
+export declare function createPrompter(options?: PrompterOptions): Prompter;

package/dist/utils/prompter.js

@@ -0,0 +1,254 @@
+/**
+ * Prompter — decouples a wizard's *decisions* from *how they're answered*.
+ *
+ * `haystack setup` historically welded every decision to inquirer/TTY, so it
+ * couldn't run headless, in CI, or under a coding agent. The Prompter is the
+ * seam: step code calls `confirm` / `multiselect` / `action`, and the
+ * implementation decides how to source the answer.
+ *
+ * Three modes, one mechanism:
+ *   - TtyPrompter  — humans in a terminal (inquirer). Default.
+ *   - JsonPrompter — a coding agent: NDJSON events on stdout, answers on stdin.
+ *                    The agent can relay a `question` to the user OR auto-answer.
+ *   - Pre-supplied answers (flags / --answers file) short-circuit any question
+ *     by id, so the same code runs fully autonomously when every answer is known.
+ *
+ * Human-facing chrome stays as `console.*`; in JSON mode the JsonPrompter
+ * redirects `console.*` to stderr so stdout carries only NDJSON.
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import * as readline from 'node:readline';
+import { readFileSync } from 'node:fs';
+function isSeparator(c) {
+    return c.separator !== undefined;
+}
+export function loadAnswersFile(path) {
+    const raw = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`--answers file must be a JSON object of {questionId: value}`);
+    }
+    return parsed;
+}
+// ---------------------------------------------------------------------------
+// TTY (human) prompter
+// ---------------------------------------------------------------------------
+class TtyPrompter {
+    answers;
+    interactive = true;
+    constructor(answers) {
+        this.answers = answers;
+    }
+    async confirm(q) {
+        if (q.id in this.answers)
+            return Boolean(this.answers[q.id]);
+        const { value } = await inquirer.prompt([
+            { type: 'confirm', name: 'value', message: q.message, default: q.default ?? true },
+        ]);
+        return value;
+    }
+    async multiselect(q) {
+        if (q.id in this.answers)
+            return this.answers[q.id];
+        const choices = q.choices.map((c) => isSeparator(c) ? new inquirer.Separator(c.separator) : { name: c.name, value: c.value, checked: c.checked });
+        const { value } = await inquirer.prompt([
+            { type: 'checkbox', name: 'value', message: q.message, choices: choices, pageSize: 20 },
+        ]);
+        return value;
+    }
+    async action(q) {
+        if (this.answers[q.id] === 'skip')
+            return false;
+        if (await q.check())
+            return true;
+        console.log(chalk.yellow(`  ${q.message}`));
+        if (q.url)
+            console.log(`  ${chalk.cyan(q.url)}`);
+        console.log(chalk.dim('  Waiting...'));
+        const started = Date.now();
+        const timeout = q.timeoutMs ?? 10 * 60 * 1000;
+        const interval = q.pollIntervalMs ?? 3000;
+        while (Date.now() - started < timeout) {
+            await sleep(interval);
+            if (await q.check())
+                return true;
+        }
+        return false;
+    }
+    progress(message, detail) {
+        process.stdout.write(`\r${chalk.dim('  ' + message)}${detail ? chalk.dim(' — ' + detail) : ''}\x1b[K`);
+    }
+    clearProgress() {
+        process.stdout.write('\r\x1b[K');
+    }
+    result(_data) {
+        // Human output is rendered inline by the step code; nothing structured to emit.
+    }
+    close() {
+        /* nothing to release */
+    }
+}
+// ---------------------------------------------------------------------------
+// JSON (coding-agent) prompter
+// ---------------------------------------------------------------------------
+class JsonPrompter {
+    answers;
+    interactive = false;
+    rl = null;
+    pending = new Map();
+    buffered = new Map();
+    restoreConsole = null;
+    constructor(answers) {
+        this.answers = answers;
+        // Keep stdout pure NDJSON: route human chrome to stderr.
+        const origLog = console.log;
+        const origWarn = console.warn;
+        const origError = console.error;
+        const toErr = (...args) => process.stderr.write(args.map(stringifyArg).join(' ') + '\n');
+        console.log = toErr;
+        console.warn = toErr;
+        console.error = toErr;
+        this.restoreConsole = () => {
+            console.log = origLog;
+            console.warn = origWarn;
+            console.error = origError;
+        };
+    }
+    emit(event) {
+        process.stdout.write(JSON.stringify(event) + '\n');
+    }
+    /** Lazily open stdin only when we actually need an answer the agent must send. */
+    ensureStdin() {
+        if (this.rl)
+            return;
+        this.rl = readline.createInterface({ input: process.stdin });
+        this.rl.on('line', (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let obj;
+            try {
+                obj = JSON.parse(trimmed);
+            }
+            catch (err) {
+                // Surface malformed input on stderr (PR001: no silent swallow) so an
+                // agent can tell its line was rejected and resend, instead of the
+                // prompt hanging on input that never parsed. stderr keeps stdout NDJSON.
+                process.stderr.write(`haystack setup: ignoring unparseable stdin line: ${err instanceof Error ? err.message : String(err)}\n`);
+                return;
+            }
+            if (!obj || typeof obj !== 'object')
+                return;
+            // Mirror OpenCode: question replies are keyed by `requestID`, permission
+            // replies by `permissionID`. Legacy `id` accepted too.
+            const key = (obj.requestID ?? obj.permissionID ?? obj.id);
+            if (typeof key !== 'string')
+                return;
+            const resolve = this.pending.get(key);
+            if (resolve) {
+                this.pending.delete(key);
+                resolve(obj);
+            }
+            else {
+                this.buffered.set(key, obj);
+            }
+        });
+    }
+    /** Wait for the agent's reply object, keyed by the request/permission id. */
+    awaitReply(id) {
+        if (this.buffered.has(id)) {
+            const v = this.buffered.get(id);
+            this.buffered.delete(id);
+            return Promise.resolve(v);
+        }
+        this.ensureStdin();
+        return new Promise((resolve) => this.pending.set(id, resolve));
+    }
+    async confirm(q) {
+        if (q.id in this.answers)
+            return Boolean(this.answers[q.id]);
+        // A confirm is a single-choice question; emit OpenCode's `question` envelope.
+        // Reply: {requestID, answers: <bool>}; reject: {requestID, reject: true}.
+        this.emit({ type: 'question', requestID: q.id, kind: 'confirm', prompt: q.message, default: q.default ?? true });
+        const reply = await this.awaitReply(q.id);
+        if (reply.reject)
+            return false;
+        const a = reply.answers ?? reply.value; // `answers` is canonical; `value` accepted
+        return typeof a === 'boolean' ? a : Boolean(a);
+    }
+    async multiselect(q) {
+        if (q.id in this.answers)
+            return this.answers[q.id];
+        const options = q.choices
+            .filter((c) => !isSeparator(c))
+            .map((c) => ({ value: c.value, label: c.name, default: c.checked ?? false }));
+        // Reply: {requestID, answers: <value[]>}; reject: {requestID, reject: true}.
+        this.emit({ type: 'question', requestID: q.id, kind: 'multiselect', prompt: q.message, options });
+        const reply = await this.awaitReply(q.id);
+        if (reply.reject)
+            return [];
+        const a = reply.answers ?? reply.value;
+        return Array.isArray(a) ? a : [];
+    }
+    async action(q) {
+        if (this.answers[q.id] === 'skip')
+            return false;
+        if (await q.check())
+            return true;
+        // An out-of-band action maps to OpenCode's `permission` request. Reply:
+        // {permissionID, response: "once"|"always"|"reject"}. We also keep polling
+        // check() so it resolves on its own once the action completes.
+        this.emit({ type: 'permission', permissionID: q.id, prompt: q.message, url: q.url, poll: true });
+        const started = Date.now();
+        const timeout = q.timeoutMs ?? 10 * 60 * 1000;
+        const interval = q.pollIntervalMs ?? 3000;
+        let override = null;
+        this.ensureStdin();
+        const answerPromise = this.awaitReply(q.id).then((reply) => {
+            const r = (reply.response ?? reply.value);
+            override = r === 'reject' || r === 'skip' ? 'skip' : 'done';
+        });
+        while (Date.now() - started < timeout) {
+            if (await q.check())
+                return true;
+            if (override === 'skip')
+                return false;
+            // 'done' means the agent reports the action complete — but completion may
+            // be eventually-consistent, so keep polling check() at the interval until
+            // it confirms or we time out (matching TTY behavior), rather than failing
+            // on a single immediate check.
+            if (override === 'done') {
+                await sleep(interval);
+                continue;
+            }
+            await Promise.race([sleep(interval), answerPromise]);
+        }
+        return false;
+    }
+    progress(message, detail) {
+        this.emit({ type: 'progress', message, ...(detail ? { detail } : {}) });
+    }
+    clearProgress() {
+        /* no ephemeral line in JSON mode */
+    }
+    result(data) {
+        this.emit({ type: 'result', ...data });
+    }
+    close() {
+        this.rl?.close();
+        this.rl = null;
+        this.restoreConsole?.();
+        this.restoreConsole = null;
+    }
+}
+export function createPrompter(options = {}) {
+    const answers = options.answers ?? {};
+    return options.json ? new JsonPrompter(answers) : new TtyPrompter(answers);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stringifyArg(a) {
+    return typeof a === 'string' ? a : String(a);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haystackeditor/cli",
-  "version": "0.14.6",
+  "version": "0.15.1",
   "description": "Set up Haystack for your project — automated PR review, triage, and merge queue",
   "type": "module",
   "bin": {