@haystackeditor/cli 0.25.0 → 0.26.0

package/dist/commands/init-capture.js

@@ -31,8 +31,9 @@ import { findCsp } from '../capture/csp.js';
 import { applyEdits, keyName, loadBabel, parseJsonLike } from '../capture/js-ast.js';
 import { buildManifest, exactRoutes, manifestDocument, MANIFEST_DIR } from '../capture/manifest.js';
 import { appContext } from '../capture/project.js';
+import { parseUrlRewrites, URL_REWRITES_QUESTION } from '../capture/url-rewrites.js';
 import { loadCaptureScript } from '../capture/script-release.js';
-import { htmlTags, STATIC_SUBDIR } from '../capture/tag.js';
+import { STATIC_SUBDIR } from '../capture/tag.js';
 import { CAPTURE_ORIGIN, CAPTURE_VERSION } from './capture-contract.js';
 import { HaystackApiError } from '../utils/haystack-api.js';
 import { lineDiff } from './init.js';
@@ -50,9 +51,10 @@ const COMPOSABLE_SCRIPT = /^[A-Za-z0-9_./=:@\s&-]+$/;
 const STAGED_DIR = `.haystack/${STATIC_SUBDIR}`;
 /** The answers in effect: the flags, else the ones init recorded in .haystack/capture.json (rule 8b: the user's answers,
  * never inferred, so a rerun that only updates the script needs none). */
-export function captureAnswers(appDir, origins, consent) {
+export function captureAnswers(appDir, origins, consent, urlRewrites) {
     const recorded = readCaptureConfig(appDir);
-    return { origins: origins.length > 0 ? origins : recorded?.origins ?? [], consent: consent ?? recorded?.consent };
+    return { origins: origins.length > 0 ? origins : recorded?.origins ?? [], consent: consent ?? recorded?.consent,
+        urlRewrites: urlRewrites ?? recorded?.urlRewrites ?? undefined };
 }
 function readText(path) {
     try {
@@ -126,6 +128,9 @@ function scriptFiles(dir) {
         return [];
     }
 }
+function formatUrlRewrites(rewrites) {
+    return rewrites.kind === 'none' ? 'none' : `hidden-segment:${rewrites.name}`;
+}
 function manifestCommand(appPath) {
     return `haystack capture manifest --app ${appPath}`;
 }
@@ -144,6 +149,7 @@ export async function planCapture(input) {
     if (input.answers.consent === undefined)
         throw new Error('planCapture needs the consent answer.');
     const consent = parseConsentChoice(input.answers.consent);
+    const urlRewrites = input.answers.urlRewrites === undefined ? null : formatUrlRewrites(parseUrlRewrites(input.answers.urlRewrites));
     const plan = { changes: [], packageText: null, needsCli: false, registration: null, notices: [], part: part([]) };
     if (input.registration && 'failed' in input.registration) {
         plan.part = part([`Run \`haystack init\` again: registering the app for capture failed (${input.registration.failed}).`]);
@@ -182,18 +188,36 @@ export async function planCapture(input) {
         key: tags.key,
         repositoryId: identity?.repositoryId ?? ID_PLACEHOLDER,
         applicationId: identity?.applicationId ?? ID_PLACEHOLDER,
-        adapter: detected && !detected.blocked ? detected.id : null,
+        // The adapter init recognized, whatever it left manual: the manifest command uses it once the cause is fixed.
+        adapter: detected ? detected.id : null,
         app: ctx.appPath,
         origins,
         consent: formatConsentChoice(consent),
         // Where a build step publishes (none for a static site, whose manifest init writes and the repository keeps).
-        publish: detected && !detected.blocked && !isManual(detected.publishDirs) && !isManual(detected.build)
-            && detected.build.kind !== 'init-writes' ? detected.publishDirs : [],
+        publish: detected && !isManual(detected.publishDirs) && !isManual(detected.build) && detected.build.kind !== 'init-writes'
+            ? detected.publishDirs : [],
+        urlRewrites,
     };
     planner.text(captureConfigFile(appDir), formatCaptureConfig(config), 'The app\'s capture identity, committed for the build step that publishes its route manifest (CAPTURE-V1 rule 8b).');
     const consentStep = manualConsentStep(consent);
-    const automatic = detected !== null && detected.blocked === null;
-    const staticDir = automatic && typeof detected.staticDir === 'string' ? detected.staticDir : null;
+    if (!detected) {
+        plan.part = { status: 'unsupported', why: `init recognized no web framework at ${ctx.appPath} (it looked for package.json, Gemfile,`
+                + ' manage.py and index.html there), and the tag records nothing without the route manifest only a recognized framework\'s routes'
+                + ' give; run `haystack init --app <dir>` with the app\'s directory' };
+        plan.changes = planner.changes;
+        return plan;
+    }
+    // A manifest that cannot be made exactly (a base path, a config init cannot read) leaves nothing worth placing: a tag
+    // without a manifest records nothing. Two steps that work: remove the cause, run init again (the recorded answers carry
+    // over, and the manifest command checks the cause on every build).
+    if (detected.manifestBlocked) {
+        steps.push(`Remove what stops ${detected.label}'s route manifest: ${detected.manifestBlocked} (init looked at ${detected.looked.join(', ')}).`);
+        steps.push('Then run `haystack init` again: it places the tag, the files and the build step that publishes the manifest itself.');
+        plan.changes = planner.changes;
+        plan.part = part(steps);
+        return plan;
+    }
+    const staticDir = typeof detected.staticDir === 'string' ? detected.staticDir : null;
     // The files: in the app's static output, or staged for a manual step.
     const filesDir = staticDir === null ? join(appDir, STAGED_DIR) : join(appDir, staticDir, STATIC_SUBDIR);
     const wanted = new Set([script.file, ...(consentFile ? [consentFile.file] : [])]);
@@ -205,24 +229,8 @@ export async function planCapture(input) {
         if (!wanted.has(old))
             planner.remove(join(filesDir, old), 'An earlier capture file, replaced by this version.');
     const servedAt = `/${STATIC_SUBDIR}/`;
-    if (!automatic) {
-        const why = detected ? `${detected.label}: ${detected.blocked}` : `init recognized no framework at ${ctx.appPath}`;
-        const looked = detected?.looked.join(', ') ?? `${ctx.appPath} (package.json, Gemfile, manage.py, index.html)`;
-        steps.push(`Add the tag yourself (${why}; init looked at ${looked}):\n${(detected ? detected.manualTag(tags) : ['Inside <head> of every page:', ...htmlTags(tags)]).map(line => `  ${line}`).join('\n')}`);
-        steps.push(`Serve the files init staged in ${posix.join(ctx.appPath, STAGED_DIR)}/ at ${servedAt} on each production origin.`);
-        steps.push(`Publish the route manifest (CAPTURE-V1 rule 4) after each build at /${MANIFEST_DIR}/current.json and`
-            + ` /${MANIFEST_DIR}/<release>.json on each production origin; until one is published the tag records nothing.`
-            + ` \`${manifestCommand(ctx.appPath)}\` generates it only for an app init sets up itself: once the reason above is gone,`
-            + ' run `haystack init` again and it adds that build step.');
-        steps.push(`If production sends a Content-Security-Policy, it needs: ${cspFallbackLine()}.`);
-        if (consentStep)
-            steps.push(consentStep);
-        plan.changes = planner.changes;
-        plan.part = part(steps);
-        return plan;
-    }
     // The tag.
-    const integration = await detected.integrate(tags);
+    const integration = detected.blocked ? { manual: detected.blocked } : await detected.integrate(tags);
     if (isManual(integration)) {
         steps.push(`Add the tag yourself (${integration.manual}; init looked at ${detected.looked.join(', ')}):\n${detected.manualTag(tags).map(line => `  ${line}`).join('\n')}`);
     }
@@ -234,8 +242,17 @@ export async function planCapture(input) {
         steps.push(`Serve ${posix.join(ctx.appPath, STAGED_DIR)} at ${servedAt}: ${detected.staticDir.manual}.`);
     // The build step and where the manifest goes.
     await planBuild(plan, planner, steps, ctx, detected, config);
-    // Routes now, so a router init cannot read is a step today rather than a manifest missing after the next build.
-    if (!isManual(detected.build) && detected.build.kind !== 'rake') {
+    if (detected.publishNote)
+        plan.notices.push(`Capture: ${detected.publishNote}`);
+    // A middleware or proxy that may rewrite page URLs: the routes are exact only with the user's answer.
+    if (detected.rewriting && urlRewrites === null)
+        steps.push(`Answer one question about URL rewrites: ${detected.rewriting}. ${URL_REWRITES_QUESTION}`);
+    // Routes now, so a router init cannot read is a step today rather than a manifest missing after the next build; an
+    // adapter whose routes come from the build reads them there.
+    if (detected.fromBuild) {
+        plan.notices.push(`Capture: the routes come from each production build (${detected.label}), read after it by the build step.`);
+    }
+    else if (!isManual(detected.build) && detected.build.kind !== 'rake') {
         const routes = exactRoutes(await detected.routes({}));
         if (isManual(routes))
             steps.push(`Make the routes readable or publish the manifest yourself: ${routes.manual}.`);

package/dist/commands/init-telemetry.js

@@ -20,8 +20,8 @@
  *   - the report (8e). InitTelemetryReport, plus the person's steps beside it: the ingest token (init never mints, prints,
  *     stores or reads one), production's environment, the start command, the deploy and the off switches (13c).
  */
-import { spawnSync } from 'node:child_process';
-import { existsSync, lstatSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync, lstatSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -31,8 +31,10 @@ import { gatewayFetch } from './case-batch.js';
 import { CAPTURE_EVIDENCE_FRESH_HOURS, CAPTURE_STATUS_PATH, } from './capture-contract.js';
 import { captureAnswers, planCapture } from './init-capture.js';
 import { discoverApps } from '../capture/adapters/index.js';
+import { CAPTURE_CONFIG_PATH, recordedApps } from '../capture/app-config.js';
 import { loadBabel } from '../capture/js-ast.js';
 import { lineDiff } from './init.js';
+import { lockfileDrift, mergePnpmLockfile } from './lockfile-pin.js';
 import { readTelemetryServerStatus } from './telemetry-token.js';
 import { readFacts } from './verify-onboarding.js';
 /** Lane D1: with the user's yes, init checks browser capture's registration with Haystack around the writes. */
@@ -214,15 +216,20 @@ function planDependency(gitRoot, appDir, pkg, after, need) {
     const spec = `${CLI_PACKAGE}@${version}`;
     const dev = field === 'devDependencies';
     const workspaceRoot = isFile(join(appDir, 'pnpm-workspace.yaml')) ? ['--workspace-root'] : [];
+    // Each package manager's add, as it changes no lockfile entry but the CLI's own (lockfile-pin.ts): npm with its tree
+    // nested under the CLI (hoisting would replace packages the app already locks), pnpm through the merge.
     const argv = manager === null ? null : {
         pnpm: ['pnpm', 'add', '--save-exact', dev ? '--save-dev' : '--save-prod', ...workspaceRoot, spec],
-        npm: ['npm', 'install', '--save-exact', dev ? '--save-dev' : '--save-prod', spec],
+        npm: ['npm', 'install', '--save-exact', dev ? '--save-dev' : '--save-prod', '--install-strategy=nested', spec],
         yarn: ['yarn', 'add', '--exact', ...(dev ? ['--dev'] : []), spec],
         bun: ['bun', 'add', '--exact', ...(dev ? ['--dev'] : []), spec],
     }[manager.name];
     const action = promoting ? `Moved from devDependencies to dependencies at ${version}` : `Pinned to ${version}`;
+    const lockfileNote = manager?.name === 'pnpm'
+        ? `, keeping every other entry of pnpm's lockfile as it was (pnpm's own add re-resolves packages the CLI shares with the app; init adds only the CLI's entries, then \`pnpm install --frozen-lockfile\`)`
+        : `, which adds only the CLI's entries to ${manager?.name}'s lockfile`;
     const reason = argv
-        ? `${why} ${action} with \`${argv.join(' ')}\` in ${inside(gitRoot, appDir)}, which updates ${manager?.name}'s lockfile too.`
+        ? `${why} ${action} with \`${argv.join(' ')}\` in ${inside(gitRoot, appDir)}${lockfileNote}.`
         : `${why} ${action}: a newer release never reaches your build unless you change it.`;
     // The package manager's own word is not taken for it: the manifest must say what the integration needs.
     const check = () => {
@@ -235,7 +242,39 @@ function planDependency(gitRoot, appDir, pkg, after, need) {
         return null;
     };
     const touches = manager === null ? [] : LOCKFILES.map(([lockfile]) => join(manager.root, lockfile));
-    return { kind: 'change', change: change(gitRoot, pkg.path, reason, after, content, argv ? { argv, cwd: appDir, touches, check } : undefined) };
+    const exec = manager === null || argv === null ? undefined : () => pin(manager, appDir, argv);
+    return { kind: 'change', change: change(gitRoot, pkg.path, reason, after, content, argv ? { argv, cwd: appDir, touches, check, exec } : undefined) };
+}
+/** The lockfile a package manager writes, in a format lockfile-pin.ts reads (bun's binary lockb aside). */
+function textLockfile(manager) {
+    const name = { pnpm: 'pnpm-lock.yaml', npm: 'package-lock.json', yarn: 'yarn.lock', bun: 'bun.lock' }[manager.name];
+    const path = join(manager.root, name);
+    return isFile(path) ? { path, format: manager.name } : null;
+}
+/** Runs the add, so that the lockfile gains the CLI's entries and nothing else moves (rule 13); throws (init then restores
+ * every file) when the package manager moved anything else. */
+function pin(manager, appDir, argv) {
+    const run = (command) => { execFileSync(command[0], command.slice(1), { cwd: appDir, stdio: ['ignore', 2, 2] }); };
+    const lockfile = textLockfile(manager);
+    const before = lockfile ? readFileSync(lockfile.path, 'utf8') : null;
+    const importer = posix.normalize(relative(manager.root, appDir).split(sep).join('/')) || '.';
+    if (manager.name === 'pnpm' && lockfile && before !== null) {
+        // pnpm resolves the CLI, init keeps the rest as it was, and the install takes exactly that lockfile (proving it).
+        run([...argv, '--lockfile-only']);
+        writeFileSync(lockfile.path, mergePnpmLockfile(before, readFileSync(lockfile.path, 'utf8'), importer, CLI_PACKAGE));
+        run(['pnpm', 'install', '--frozen-lockfile']);
+    }
+    else {
+        run(argv);
+    }
+    if (!lockfile || before === null)
+        return;
+    const moved = lockfileDrift(lockfile.format, before, readFileSync(lockfile.path, 'utf8'), importer, CLI_PACKAGE);
+    if (moved.length > 0) {
+        throw new Error(`\`${argv.join(' ')}\` also changed ${moved.length} lockfile ${moved.length === 1 ? 'entry' : 'entries'} the CLI does not own`
+            + ` (${moved.slice(0, 5).join(', ')}${moved.length > 5 ? ', …' : ''}), so init put every file back. Add ${CLI_PACKAGE} at its exact version`
+            + ` to ${inside(manager.root, appDir) || '.'} yourself, keeping the lockfile's other entries, then run \`haystack init\` again`);
+    }
 }
 function isNode(value) {
     return !!value && typeof value === 'object' && typeof value.type === 'string' && typeof value.start === 'number';
@@ -819,13 +858,18 @@ export async function planTelemetry(gitRoot, repository, options) {
         // One rule for which directories are apps (capture/adapters/index.ts): a web framework an adapter claims, or a package
         // with a start script.
         await loadBabel();
-        const apps = await discoverApps(gitRoot);
+        // The user's earlier answer first: the one app a .haystack/capture.json records (with its origins and consent, which
+        // captureAnswers reads from it). Several records are as ambiguous as several apps.
+        const discovered = await discoverApps(gitRoot);
+        const recorded = recordedApps(gitRoot, discovered);
+        const apps = recorded.length > 0 ? recorded : discovered;
         if (apps.length !== 1) {
             // Rule 8(a): init never picks among several apps, and never guesses one where it found none.
             const ask = apps.length === 0
                 ? 'init found no app here (no web framework it recognizes and no package with a start script). If the repository has one that serves production, run '
                     + '`haystack init` again with `--app <its directory>`.'
-                : `Ask your user which of these apps serves production: ${apps.join(', ')}; then run \`haystack init\` again with \`--app <that directory>\`.`;
+                : `Ask your user which of these apps serves production: ${apps.join(', ')}${recorded.length > 0 ? ` (each has a ${CAPTURE_CONFIG_PATH})` : ''};`
+                    + ' then run `haystack init` again with `--app <that directory>`.';
             const questions = [ask, ...captureQuestions(options.origins, options.consent)];
             // A notice too, so a preview (which reports no telemetry yet) already says what to ask.
             notices.push(`Telemetry waits for your user's answers: ${questions.join(' ')}`);
@@ -834,6 +878,8 @@ export async function planTelemetry(gitRoot, repository, options) {
                 captureRegistration: null };
         }
         appDir = realpathSync(join(gitRoot, apps[0]));
+        if (recorded.length > 0)
+            notices.push(`Telemetry: the app is ${apps[0]}, as its ${CAPTURE_CONFIG_PATH} records (\`--app\` picks another).`);
     }
     const app = inside(gitRoot, appDir);
     const changes = [];
@@ -841,7 +887,7 @@ export async function planTelemetry(gitRoot, repository, options) {
     const manifest = join(appDir, 'package.json');
     // CONNECT(lane D1): browser capture (init-capture.ts) plans with the answers in effect (flags, else the ones init recorded
     // for this app); a missing answer is a question, never a guess.
-    const answers = captureAnswers(appDir, options.origins, options.consent);
+    const answers = captureAnswers(appDir, options.origins, options.consent, options.urlRewrites);
     const questions = captureQuestions(answers.origins, answers.consent);
     const capture = questions.length > 0 ? null
         : await planCapture({ gitRoot, appDir, repository, answers, registration: options.registration });
@@ -940,19 +986,36 @@ function dbProfile(repository, onboarding, notes) {
                         + '`haystack db profile upload --help` says how a profile names the one it describes.'] : []),
         ] };
 }
+function serverPartOf(plan) {
+    return plan.server.status === 'unsupported' ? { status: 'unsupported', why: plan.server.why }
+        : plan.server.status === 'manual' ? { status: 'manual', steps: plan.server.steps, received: null } : { status: 'installed', received: null };
+}
+const WAITING_STEP = 'Telemetry waits for answers only your user can give: ask what the `steps` of each `manual` part say, then run `haystack init` '
+    + 'again with them.';
+/** Rule 8(e) before anything is changed (a preview without --yes, or no login yet): the report the apply gives, with
+ * `received` null (checking it needs Haystack), so the coding agent can show its user what telemetry will do; with the steps that need
+ * nothing from Haystack (the token and environment steps follow with --yes). */
+export function previewTelemetry(plan, repository, notes) {
+    const steps = [];
+    if (plan.app === null || plan.capture.status === 'manual')
+        steps.push(WAITING_STEP);
+    if (plan.app !== null && plan.server.status !== 'unsupported') {
+        steps.push(`With --yes, init then says how production gets its telemetry token (\`haystack telemetry token --repo ${repository}\`, run by your`
+            + ' user in their own terminal) and which variables production\'s server environment needs.');
+    }
+    const profile = dbProfile(repository, null, notes);
+    return { telemetry: { capture: plan.capture, server: serverPartOf(plan), dbProfileCommand: profile?.command ?? null }, steps };
+}
 /** Rule 8(e): the report, and what the person does for telemetry to arrive (the token, production's environment, the start,
  * the deploy) with the off switches (rule 13c). `onboarding` and `notes` feed the data profile. */
 export async function telemetryReport(plan, context) {
     const { repository, token } = context;
     const steps = [];
-    const serverPart = plan.server.status === 'unsupported' ? { status: 'unsupported', why: plan.server.why }
-        : plan.server.status === 'manual' ? { status: 'manual', steps: plan.server.steps, received: null } : { status: 'installed', received: null };
+    const serverPart = serverPartOf(plan);
     let server = serverPart;
     // Answers only the user can give come first: until then the rest of telemetry waits (rule 8: init never guesses).
-    if (plan.app === null || plan.capture.status === 'manual') {
-        steps.push('Telemetry waits for answers only your user can give: ask what the `steps` of each `manual` part say, then run `haystack init` '
-            + 'again with them.');
-    }
+    if (plan.app === null || plan.capture.status === 'manual')
+        steps.push(WAITING_STEP);
     if (plan.app !== null && plan.server.status !== 'unsupported') {
         const status = await readTelemetryServerStatus(repository, token);
         server = withReceived(serverPart, status.newestFlush === null ? null : received(status.newestFlush.storedAt, status.newestFlush.buildId));

package/dist/commands/init.js

@@ -54,9 +54,11 @@ export const AGENT_NOTE = [
     '- Fix each bug it reports that your change caused, then run `haystack verify` again.',
     '- If it says onboarding needs an answer, ask the user that question and file their choice with',
     '  `haystack verify answer <question-id> <choice>`.',
-    '- Read its short report. `--json` prints the full result, often hundreds of kilobytes, for scripts;',
+    '- Read its short report. `--json` prints the same report as data; `--raw` prints the crawl\'s whole record (large), for scripts;',
     '  `haystack verify --help` explains the output and exit codes.',
     '- If `haystack` is not installed, run each command as `npx -y @haystackeditor/cli@latest <command>`.',
+    '- If Haystack fails, confuses you or gets in your way, say so in a sentence with',
+    '  `haystack feedback "<what happened>"` and keep going: the Haystack team sees it at once.',
     NOTE_END,
 ].join('\n');
 const EXIT_CODES = { planned: 2, 'login-required': 4, 'app-required': 5 };
@@ -310,7 +312,10 @@ function applyChange(gitRoot, planned) {
     if (planned.run) {
         const before = existsSync(planned.target) ? readFileSync(planned.target, 'utf8') : '';
         // Its output goes to stderr: in --json mode stdout carries only the one document.
-        execFileSync(planned.run.argv[0], planned.run.argv.slice(1), { cwd: planned.run.cwd, stdio: ['ignore', 2, 2] });
+        if (planned.run.exec)
+            planned.run.exec();
+        else
+            execFileSync(planned.run.argv[0], planned.run.argv.slice(1), { cwd: planned.run.cwd, stdio: ['ignore', 2, 2] });
         const failed = planned.run.check?.() ?? null;
         if (failed !== null)
             throw new Error(`\`${planned.run.argv.join(' ')}\` ran, but ${failed}.`);
@@ -359,18 +364,26 @@ export async function initCommand(options) {
     const plan = planInit(gitRoot);
     // Telemetry is part of onboarding (CAPTURE-V1 rule 8): planned on every run; a missing answer stops only it.
     const telemetryModule = await import('./init-telemetry.js');
-    const telemetryOptions = { app: options.app, origins: options.origin ?? [], consent: options.consent };
+    const telemetryOptions = { app: options.app, origins: options.origin ?? [], consent: options.consent, urlRewrites: options.urlRewrites };
     let telemetryPlan = await telemetryModule.planTelemetry(gitRoot, repository, telemetryOptions);
     const telemetryFrom = plan.changes.length;
     plan.changes.push(...telemetryPlan.changes);
     plan.notices.push(...telemetryPlan.notices);
     let notesWritten = null;
     let telemetry = null;
+    // Before the apply (a preview, or no login), the report is the preview: what telemetry will do, `received` unchecked (null).
+    const report = () => telemetry ?? telemetryModule.previewTelemetry(telemetryPlan, repository, notes);
+    const showPreview = () => {
+        const preview = telemetryModule.previewTelemetry(telemetryPlan, repository, notes);
+        for (const line of telemetryModule.formatTelemetry(preview.telemetry, preview.steps))
+            say(line);
+        say('');
+    };
     const finish = (status, onboarding, exitCode) => {
         if (options.json) {
             const changes = plan.changes.map(({ path, action, reason, diff }) => ({ path, action, reason, diff }));
             process.stdout.write(`${JSON.stringify(withSchema('init', { status, repository, changes, notices: plan.notices, notes: notesWritten,
-                onboarding, telemetry: telemetry?.telemetry ?? null, telemetrySteps: telemetry?.steps ?? [] }), null, 2)}\n`);
+                onboarding, telemetry: report().telemetry, telemetrySteps: report().steps }), null, 2)}\n`);
         }
         process.exitCode = exitCode;
     };
@@ -397,6 +410,7 @@ export async function initCommand(options) {
     catch (error) {
         if (!(error instanceof NotLoggedInError))
             throw error;
+        showPreview();
         say(chalk.yellow('Not logged in, so nothing was changed. Run `haystack login`, then `haystack init` again.'));
         finish('login-required', null, EXIT_CODES['login-required']);
         return;
@@ -404,6 +418,7 @@ export async function initCommand(options) {
     if (plan.changes.length > 0 && !options.yes) {
         const interactive = !options.json && process.stdin.isTTY === true && process.stdout.isTTY === true;
         if (!interactive || !await confirmed()) {
+            showPreview();
             say('Nothing was changed. Run `haystack init --yes` to make these changes.');
             finish('planned', null, EXIT_CODES.planned);
             return;