@contentful/experience-design-system-cli 2.12.0 → 2.12.1-dev-build-589b615.0

package/dist/src/import/command.js

@@ -1,7 +1,12 @@
 import { resolve, join } from 'node:path';
 import { runPipeline } from './orchestrator.js';
+import { resolveAutoFilter } from './auto-filter-resolve.js';
+import { resolveAgent, resolveModel } from './agent-model-resolve.js';
 import { readExperiencesCredentials } from '../credentials-store.js';
 import { DEFAULT_CONFIGURED_HOST, toConfiguredHost } from '../host-utils.js';
+import { replayRun, modifyRun } from '../runs/replay-helpers.js';
+import { resolvePromptFlags } from './print-prompt.js';
+import { shouldShowRunPicker } from '../runs/run-picker-mount.js';
 export function registerImportCommand(program) {
     program
         .command('import')
@@ -11,9 +16,10 @@ export function registerImportCommand(program) {
         .option('--cma-token <token>', 'CMA personal access token (or set CONTENTFUL_MANAGEMENT_TOKEN)')
         .option('--project <path>', 'Path to the project root to analyze', '.')
         .option('--out <path>', 'Output directory for pipeline artifacts')
-        .option('--agent <name>', 'Agent to use for generate components', 'claude')
+        .option('--agent <name>', 'Agent to use for generate components (overrides credentials.json; falls back to "claude")')
         .option('--model <name>', 'Model to use for generate components (defaults to a small/fast model per agent)')
         .option('--tokens <path>', 'Path to a DTCG tokens.json file to push alongside generated components')
+        .option('--raw-tokens <path>', 'Path to a raw token source file (SCSS, CSS variables, JS/TS, Style Dictionary, etc.) to classify and import alongside components. Bypasses the interactive token prompt.')
         .option('--select-all', 'Select all extracted components for generation (default)')
         .option('--select <pattern>', 'Select components matching pattern (repeatable)', (v, a) => [...a, v], [])
         .option('--deselect <pattern>', 'Deselect components matching pattern (repeatable)', (v, a) => [...a, v], [])
@@ -27,8 +33,153 @@ export function registerImportCommand(program) {
         .option('--exclude-invalid', 'Automatically reject components with validation errors (empty names, collisions)')
         .option('--viewports <path>', 'JSON file with viewport array (passed to apply push)')
         .option('--host <url>', 'Override API base URL (passed to apply push)')
-        .option('--dry-run', 'Print generate components prompt without invoking the agent')
+        .option('--dry-run', "(deprecated, will change semantics in a future release) Print generate components prompt without invoking the agent. Use --print-prompt for the same behaviour explicitly, or '--dry-run --no-push' for the upcoming manifest-preview semantics.")
+        .option('--print-prompt', 'Print the generate components prompt without invoking the agent. Replaces the legacy --dry-run prompt-print behaviour on this command.')
+        .option('--auto-accept-scope', 'Accept all extracted components without prompting (for scripted/non-TTY callers)')
+        .option('--auto-filter', 'Force the AI auto-filter ON (overrides the credentials.json autoFilter preference)')
+        .option('--no-auto-filter', 'Skip the automatic AI pre-filter; jump straight to manual scope-gate (overrides the credentials.json autoFilter preference; no-op when paired with --auto-accept-scope)')
+        .option('--no-live-preview', 'Skip the automatic preview re-run after each FieldEditor save (no-op when paired with --auto-accept-scope)')
+        .option('--no-push', 'Run extract → scope-gate → generate → final-review and exit without pushing to Contentful (no credentials prompt; live preview disabled)')
+        .option('--no-save', 'Push without writing components.json / tokens.json to disk (default: save AND push)')
+        .option('--out-dir <path>', 'Save components.json / tokens.json to this directory; bypasses the inline save-path prompt')
+        .option('--on-conflict <mode>', "How to handle existing components.json / tokens.json at the save path: 'overwrite' replaces files, 'skip' writes to a timestamped subdirectory, 'fail' exits non-zero. Skips the wizard's interactive conflict gate when set.", (value) => {
+        if (value !== 'overwrite' && value !== 'skip' && value !== 'fail') {
+            process.stderr.write(`Error: invalid --on-conflict value '${value}'. Use one of: overwrite, skip, fail.\n`);
+            process.exit(1);
+        }
+        return value;
+    })
+        .option('--select-prompt-path <path>', 'Path to a custom .md skill prompt for analyze select-agent (bypasses bundled invariants)')
+        .option('--generate-prompt-path <path>', 'Path to a custom .md skill prompt for generate components (bypasses bundled invariants)')
+        .option('--push-from-run <id-or-path>', "Push a prior run's recorded pipeline.db session to Contentful WITHOUT writing components.json / tokens.json to disk. Accepts a run-id or filesystem path that matches a recorded savePath. Credentials are resolved from flags, then the run record, then 'experiences setup', then (in a TTY) an interactive prompt.")
+        .option('--modify <id-or-path>', 'Re-open the wizard at final-review with a prior run pre-populated for field edits. Accepts a run-id or filesystem path. Pair with --overwrite or --save-as-new to pick the save mode.')
+        .option('--overwrite', "Only valid with --modify: save back to the run's recorded savePath")
+        .option('--save-as-new', 'Only valid with --modify: always save to a new path (prompts for one)')
+        .option('--force', 'Bypass staleness checks when paired with --push-from-run or --modify.')
         .action(async (opts) => {
+        // ── --push-from-run handling ───────────────────────────────────────
+        // Push-only replay of a prior run. Mutex checks happen *before* any
+        // side effects (no DB reads, no wizard render).
+        if (opts.pushFromRun !== undefined) {
+            if (opts.modify !== undefined) {
+                process.stderr.write('Error: --push-from-run and --modify are mutually exclusive. --push-from-run pushes the recorded session; --modify re-opens the wizard for edits.\n');
+                process.exit(1);
+                return;
+            }
+            if (opts.project !== '.') {
+                process.stderr.write('Error: --push-from-run and --project are mutually exclusive. The project path is read from the recorded run.\n');
+                process.exit(1);
+                return;
+            }
+            if (opts.save === false) {
+                process.stderr.write('Error: --push-from-run and --no-save are mutually exclusive. --push-from-run never writes to disk.\n');
+                process.exit(1);
+                return;
+            }
+            if (opts.push === false) {
+                process.stderr.write('Error: --push-from-run and --no-push are mutually exclusive. Pushing is the whole point of --push-from-run.\n');
+                process.exit(1);
+                return;
+            }
+            if (opts.overwrite || opts.saveAsNew) {
+                process.stderr.write('Error: --overwrite and --save-as-new only apply with --modify.\n');
+                process.exit(1);
+                return;
+            }
+            try {
+                await replayRun({
+                    runIdOrPath: opts.pushFromRun,
+                    ...(opts.spaceId ? { spaceId: opts.spaceId } : {}),
+                    ...(opts.environmentId ? { environmentId: opts.environmentId } : {}),
+                    ...(opts.cmaToken ? { cmaToken: opts.cmaToken } : {}),
+                    ...(opts.host ? { host: opts.host } : {}),
+                    interactive: !!process.stdout.isTTY,
+                    ...(opts.force ? { force: true } : {}),
+                });
+                return;
+            }
+            catch (err) {
+                process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+                process.exit(1);
+                return;
+            }
+        }
+        // ── --modify handling ──────────────────────────────────────────────
+        if (opts.modify !== undefined) {
+            if (opts.project !== '.') {
+                process.stderr.write('Error: --modify and --project are mutually exclusive. The project path is read from the recorded run.\n');
+                process.exit(1);
+                return;
+            }
+            if (opts.overwrite && opts.saveAsNew) {
+                process.stderr.write('Error: --overwrite and --save-as-new are mutually exclusive.\n');
+                process.exit(1);
+                return;
+            }
+            try {
+                await modifyRun({
+                    runIdOrPath: opts.modify,
+                    ...(opts.overwrite ? { overwrite: true } : {}),
+                    ...(opts.saveAsNew ? { saveAsNew: true } : {}),
+                    ...(opts.outDir ? { outDir: opts.outDir } : {}),
+                    ...(opts.force ? { force: true } : {}),
+                });
+                return;
+            }
+            catch (err) {
+                process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+                process.exit(1);
+                return;
+            }
+        }
+        if (opts.overwrite || opts.saveAsNew) {
+            process.stderr.write('Error: --overwrite and --save-as-new require --modify.\n');
+            process.exit(1);
+            return;
+        }
+        if (opts.save === false && opts.push === false) {
+            process.stderr.write('Error: --no-save and --no-push together would do nothing. Pick one or neither.\n');
+            process.exit(1);
+            return;
+        }
+        if (opts.save === false && opts.outDir) {
+            process.stderr.write('Error: --no-save and --out-dir are mutually exclusive. --no-save disables disk writes; --out-dir picks a directory for them.\n');
+            process.exit(1);
+            return;
+        }
+        if (opts.save === false && opts.onConflict) {
+            process.stderr.write('Error: --no-save and --on-conflict are mutually exclusive. --no-save disables disk writes; --on-conflict only applies when files are being written.\n');
+            process.exit(1);
+            return;
+        }
+        // ── --raw-tokens validation ─────────────────────────────────────────
+        // The raw-tokens path is a source file the wizard hands to
+        // `generate tokens --raw-tokens <path>`. Validate at parse time so
+        // operators get an immediate error before the wizard renders.
+        if (opts.rawTokens !== undefined) {
+            if (opts.tokens !== undefined) {
+                process.stderr.write('Error: --raw-tokens and --tokens are mutually exclusive: --raw-tokens is the source file to classify, --tokens is a pre-classified DTCG sidecar.\n');
+                process.exit(1);
+                return;
+            }
+            const { access } = await import('node:fs/promises');
+            try {
+                await access(opts.rawTokens);
+            }
+            catch {
+                process.stderr.write(`Error: --raw-tokens: file not found: ${opts.rawTokens}\n`);
+                process.exit(1);
+                return;
+            }
+        }
+        const promptFlags = resolvePromptFlags({
+            ...(opts.dryRun !== undefined ? { dryRun: opts.dryRun } : {}),
+            ...(opts.printPrompt !== undefined ? { printPrompt: opts.printPrompt } : {}),
+        });
+        if (promptFlags.deprecationNotice) {
+            process.stderr.write(promptFlags.deprecationNotice);
+        }
+        const dryRunForward = promptFlags.forwardDryRun;
         const isHeadless = opts.skipAnalyze ||
             opts.skipGenerate ||
             opts.skipApply ||
@@ -36,23 +187,107 @@ export function registerImportCommand(program) {
             !!opts.environmentId ||
             !!opts.cmaToken ||
             opts.yes ||
-            opts.dryRun ||
+            dryRunForward ||
             false;
+        const autoAcceptScope = opts.autoAcceptScope ?? false;
+        if (!process.stdout.isTTY && !isHeadless && !autoAcceptScope) {
+            process.stderr.write('Error: experiences import is interactive. Pass --auto-accept-scope, or use a headless mode by providing credentials (--space-id, --environment-id, --cma-token) or one of --skip-analyze, --skip-generate, --skip-apply, --yes, --dry-run, --print-prompt.\n');
+            process.exit(1);
+            return;
+        }
         if (process.stdout.isTTY && !isHeadless) {
             const { render } = await import('ink');
             const { createElement } = await import('react');
             const { WizardApp } = await import('./tui/WizardApp.js');
             const creds = await readExperiencesCredentials();
+            // Parity-audit Q4: resolve --agent / --model overrides against the
+            // stored credentials.json so both flags are functional for the
+            // wizard path. Flag wins, then stored value, then default.
+            const resolvedAgent = resolveAgent(opts.agent, creds.agent);
+            const resolvedModel = resolveModel(opts.model, creds.agentModel);
+            // ── Run picker decision ─────────────────────────────────────────
+            // When runs.json has prior entries and the operator didn't ask for
+            // a specific entry point, open the wizard with the run picker. The
+            // helper enforces every gate (TTY, conflicting flags, file state).
+            const pickerDecision = await shouldShowRunPicker({
+                flags: {
+                    ...(opts.pushFromRun !== undefined ? { pushFromRun: opts.pushFromRun } : {}),
+                    ...(opts.modify !== undefined ? { modify: opts.modify } : {}),
+                    ...(opts.project !== '.' ? { project: opts.project } : {}),
+                    ...(opts.autoAcceptScope ? { autoAcceptScope: true } : {}),
+                    ...(opts.dryRun ? { dryRun: true } : {}),
+                },
+                isTTY: !!process.stdin.isTTY,
+            });
+            let pickerSelection = null;
+            const pickerProps = {};
+            if (pickerDecision.shouldShow) {
+                pickerProps.initialRuns = pickerDecision.runs;
+                pickerProps.onRunPicked = (selection) => {
+                    pickerSelection = selection;
+                    setImmediate(() => process.exit(0));
+                };
+            }
             const { waitUntilExit } = render(createElement(WizardApp, {
                 initialSpaceId: creds.spaceId,
                 initialEnvironmentId: creds.environmentId || 'master',
                 initialCmaToken: creds.cmaToken,
                 initialHost: toConfiguredHost(opts.host ?? creds.host) ?? DEFAULT_CONFIGURED_HOST,
-                initialAgent: opts.agent !== 'claude' ? opts.agent : undefined,
+                initialAgent: resolvedAgent,
+                ...(resolvedModel ? { initialModel: resolvedModel } : {}),
                 initialProjectPath: opts.project !== '.' ? resolve(opts.project) : undefined,
                 host: opts.host,
+                autoAcceptScope,
+                noCache: opts.cache === false,
+                autoFilter: resolveAutoFilter({ autoFilter: opts.autoFilter }, creds.autoFilter),
+                livePreview: opts.livePreview !== false,
+                noPush: opts.push === false,
+                noSave: opts.save === false,
+                ...(opts.outDir ? { outDirOverride: resolve(opts.outDir) } : {}),
+                ...(opts.onConflict ? { onConflictMode: opts.onConflict } : {}),
+                selectPromptPath: opts.selectPromptPath ?? creds.selectPromptPath,
+                generatePromptPath: opts.generatePromptPath ?? creds.generatePromptPath,
+                ...(opts.rawTokens ? { initialRawTokensPath: resolve(opts.rawTokens) } : {}),
+                ...pickerProps,
             }));
-            await waitUntilExit();
+            try {
+                await waitUntilExit();
+            }
+            catch {
+                /* Ink throws on process.exit; swallow so picker dispatch can run. */
+            }
+            // ── Picker dispatch ─────────────────────────────────────────────
+            // If the operator picked a run, route into the existing entry
+            // points so credential resolution and mutex checks stay in one
+            // place. The --modify path resolves the run record via
+            // resolveRunTarget and threads its session IDs through
+            // launchModifyWizard (see runs/replay-helpers.ts).
+            if (pickerSelection) {
+                const sel = pickerSelection;
+                if (sel.action === 'push' && sel.runId) {
+                    await replayRun({
+                        runIdOrPath: sel.runId,
+                        ...(opts.spaceId ? { spaceId: opts.spaceId } : {}),
+                        ...(opts.environmentId ? { environmentId: opts.environmentId } : {}),
+                        ...(opts.cmaToken ? { cmaToken: opts.cmaToken } : {}),
+                        ...(opts.host ? { host: opts.host } : {}),
+                        interactive: !!process.stdout.isTTY,
+                        ...(opts.force ? { force: true } : {}),
+                    });
+                    return;
+                }
+                if (sel.action === 'modify' && sel.runId) {
+                    await modifyRun({
+                        runIdOrPath: sel.runId,
+                        ...(opts.outDir ? { outDir: opts.outDir } : {}),
+                        ...(opts.overwrite ? { overwrite: true } : {}),
+                        ...(opts.saveAsNew ? { saveAsNew: true } : {}),
+                        ...(opts.force ? { force: true } : {}),
+                    });
+                    return;
+                }
+                // action === 'new' falls through — the wizard already advanced.
+            }
             return;
         }
         const skipApply = opts.skipApply ?? false;
@@ -66,14 +301,18 @@ export function registerImportCommand(program) {
         }
         const projectRoot = resolve(opts.project);
         const outDir = opts.out ? resolve(opts.out) : join(projectRoot, '.contentful');
+        // Parity-audit Q4: also honor stored agent/model in headless mode.
+        const headlessCreds = await readExperiencesCredentials();
+        const headlessAgent = resolveAgent(opts.agent, headlessCreds.agent);
+        const headlessModel = resolveModel(opts.model, headlessCreds.agentModel);
         const result = await runPipeline({
             project: projectRoot,
             out: outDir,
             spaceId,
             environmentId,
             cmaToken,
-            agent: opts.agent,
-            model: opts.model,
+            agent: headlessAgent,
+            model: headlessModel,
             tokens: opts.tokens,
             selectAll: opts.selectAll,
             select: opts.select.length > 0 ? opts.select : undefined,
@@ -88,7 +327,8 @@ export function registerImportCommand(program) {
             excludeInvalid: opts.excludeInvalid ?? false,
             viewports: opts.viewports,
             host: opts.host,
-            dryRun: opts.dryRun,
+            dryRun: dryRunForward,
+            selectPromptPath: opts.selectPromptPath,
         }, (line) => process.stderr.write(line + '\n'));
         const hasFailed = result.steps.some((s) => s.status === 'failed');
         if (!process.stdout.isTTY) {

package/dist/src/import/orchestrator.d.ts

@@ -21,6 +21,8 @@ export interface PipelineOptions {
     selectAll?: boolean;
     select?: string[];
     deselect?: string[];
+    /** Forwarded to the spawned `analyze select-agent` subprocess. */
+    selectPromptPath?: string;
 }
 export interface StepResult {
     step: string;

package/dist/src/import/orchestrator.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { execFile } from 'node:child_process';
 import { openPipelineDb, getOrCreateSession, createStep, updateStep, findLatestSessionForCommand, } from '../session/db.js';
 import { PREVIEW_ERROR_PREFIX, VALIDATION_FAILED_CODE, parsePreviewValidationErrors } from '../apply/api-client.js';
+import { buildPostPushUrl } from '../lib/contentful-urls.js';
 function findCliPath() {
     return join(fileURLToPath(import.meta.url), '..', '..', '..', '..', 'bin', 'cli.js');
 }
@@ -174,6 +175,10 @@ export async function runPipeline(opts, progressWriter, cliPathOverride) {
                 editArgs.push('--model', opts.model);
             if (opts.excludeInvalid)
                 editArgs.push('--exclude-invalid');
+            if (opts.noCache)
+                editArgs.push('--no-cache');
+            if (opts.selectPromptPath)
+                editArgs.push('--select-prompt-path', opts.selectPromptPath);
         }
         else {
             editArgs = ['analyze', 'select', '--session', extractSessionId];
@@ -449,10 +454,13 @@ export async function runPipeline(opts, progressWriter, cliPathOverride) {
     progressWriter('');
     progressWriter(`Pipeline complete. Session: ${sessionId}`);
     if (opts.spaceId && opts.environmentId && !opts.skipApply) {
-        const apiHost = opts.host ?? 'api.contentful.com';
-        const appHost = apiHost.replace(/^api\./, 'app.');
+        const viewUrl = buildPostPushUrl({
+            host: opts.host ?? 'api.contentful.com',
+            spaceId: opts.spaceId,
+            environmentId: opts.environmentId,
+        });
         progressWriter('');
-        progressWriter(`View your design system:  https://${appHost}/spaces/${opts.spaceId}/environments/${opts.environmentId}/components`);
+        progressWriter(`View your design system:  ${viewUrl}`);
     }
     db.close();
     return { session: sessionId, project: projectRoot, steps };

package/dist/src/import/print-prompt.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `experiences import --print-prompt` / `--dry-run` — prompt-print helpers.
+ *
+ * Both flags currently surface the same behaviour: print the generate-prompt
+ * (delegated downstream by the orchestrator via `generate components --dry-run`)
+ * and exit before invoking the agent. `--print-prompt` is the new, explicit
+ * name. `--dry-run` is preserved for one deprecation cycle: it keeps working
+ * but emits a stderr notice signalling that its semantics will change in a
+ * future release (to "manifest preview, no push", matching `apply push`'s
+ * `--dry-run`).
+ *
+ * Keeping the routing in a small pure module lets the command surface stay
+ * declarative and lets the deprecation notice be asserted from tests without
+ * spawning the full pipeline.
+ */
+export declare const DRY_RUN_DEPRECATION_NOTICE: string;
+export type PromptFlags = {
+    /** True when the user passed --dry-run. */
+    dryRun?: boolean;
+    /** True when the user passed --print-prompt. */
+    printPrompt?: boolean;
+};
+export type PromptFlagsResolution = {
+    /** Whether to forward `--dry-run` semantics to the downstream generate step. */
+    forwardDryRun: boolean;
+    /** Stderr message to emit, or null when the flags need no warning. */
+    deprecationNotice: string | null;
+};
+/**
+ * Resolve the user's `--dry-run` / `--print-prompt` choice into the
+ * downstream-forwarded dry-run boolean plus an optional deprecation message.
+ * Pure (no IO) so it's trivially unit-testable; the caller writes the notice
+ * to stderr.
+ */
+export declare function resolvePromptFlags(flags: PromptFlags): PromptFlagsResolution;

package/dist/src/import/print-prompt.js

@@ -0,0 +1,31 @@
+/**
+ * `experiences import --print-prompt` / `--dry-run` — prompt-print helpers.
+ *
+ * Both flags currently surface the same behaviour: print the generate-prompt
+ * (delegated downstream by the orchestrator via `generate components --dry-run`)
+ * and exit before invoking the agent. `--print-prompt` is the new, explicit
+ * name. `--dry-run` is preserved for one deprecation cycle: it keeps working
+ * but emits a stderr notice signalling that its semantics will change in a
+ * future release (to "manifest preview, no push", matching `apply push`'s
+ * `--dry-run`).
+ *
+ * Keeping the routing in a small pure module lets the command surface stay
+ * declarative and lets the deprecation notice be asserted from tests without
+ * spawning the full pipeline.
+ */
+export const DRY_RUN_DEPRECATION_NOTICE = "Warning: '--dry-run' on 'experiences import' will change semantics in a future release; " +
+    "use '--print-prompt' to print the prompt or '--dry-run --no-push' to preview the manifest.\n";
+/**
+ * Resolve the user's `--dry-run` / `--print-prompt` choice into the
+ * downstream-forwarded dry-run boolean plus an optional deprecation message.
+ * Pure (no IO) so it's trivially unit-testable; the caller writes the notice
+ * to stderr.
+ */
+export function resolvePromptFlags(flags) {
+    const forwardDryRun = !!(flags.dryRun || flags.printPrompt);
+    // Only the bare `--dry-run` path emits the deprecation notice; pairing it
+    // with `--print-prompt` (or using `--print-prompt` alone) opts the operator
+    // into the new explicit name, so we stay quiet.
+    const deprecationNotice = flags.dryRun && !flags.printPrompt ? DRY_RUN_DEPRECATION_NOTICE : null;
+    return { forwardDryRun, deprecationNotice };
+}

package/dist/src/import/tui/CustomPromptBanner.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+/**
+ * Feature 8: top-of-wizard banner shown while any custom skill prompt is
+ * active. Persists at every step so the operator cannot miss that bundled
+ * invariants are bypassed.
+ */
+export interface CustomPromptBannerProps {
+    selectPromptPath?: string;
+    generatePromptPath?: string;
+}
+export declare function CustomPromptBanner({ selectPromptPath, generatePromptPath, }: CustomPromptBannerProps): React.ReactElement | null;

package/dist/src/import/tui/CustomPromptBanner.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function CustomPromptBanner({ selectPromptPath, generatePromptPath, }) {
+    if (!selectPromptPath && !generatePromptPath)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { color: "yellow", bold: true, children: "WARNING: Custom prompt active" }), selectPromptPath ? _jsxs(Text, { color: "yellow", children: ["select: ", selectPromptPath] }) : null, generatePromptPath ? _jsxs(Text, { color: "yellow", children: ["components: ", generatePromptPath] }) : null, _jsx(Text, { color: "yellow", dimColor: true, children: "Bundled invariants (utility-wrapper rejection, description content rules) do NOT apply." })] }));
+}

package/dist/src/import/tui/WizardApp.d.ts

@@ -1,24 +1,128 @@
 import React from 'react';
-export declare function buildAnalyzeSelectArgs(opts: {
+import { type RunPickerSelection } from '../../runs/run-picker.js';
+import type { RunRecord } from '../../runs/store.js';
+import { type OnConflictMode } from '../../runs/save-path-resolver.js';
+export declare function buildSelectAgentArgs(opts: {
     sessionId: string;
-    acceptAll: boolean;
+    agent: string;
+    /** Parity-audit Q4: forward `--model` override from `experiences import`. */
+    model?: string;
+    /** Feature 8: forward to the spawned select-agent subprocess. */
+    selectPromptPath?: string;
+    /**
+     * Forward the operator's `experiences import --no-cache` through to the
+     * spawned `analyze select-agent` so PR #59's per-component select-cache is
+     * bypassed on this run. Default (omitted/false) preserves cache behavior.
+     */
+    noCache?: boolean;
+}): string[];
+export type AutoFilterProgress = {
+    n: number;
+    total: number;
+    decision: 'accepted' | 'rejected';
+    name: string;
+    reason: string;
+};
+export declare function parseAutoFilterProgressLine(line: string): AutoFilterProgress | null;
+export declare function buildGenerateComponentsArgs(opts: {
+    sessionId: string;
+    tokensPath?: string;
+    agent: string;
+    /** Parity-audit Q4: forward `--model` override from `experiences import`. */
+    model?: string;
+    noCache?: boolean;
+    /** Feature 8: forward to the spawned generate components subprocess. */
+    generatePromptPath?: string;
 }): string[];
 export declare function formatAcceptanceSummary(opts: {
     accepted: number;
     autoRejected: number;
 }): string;
-export declare function formatGeneratedSummary(opts: {
-    generated: number;
-    renamedSlots: number;
-    autoRejected: number;
-}): string;
+/**
+ * Parse the `wrote tokens.json (N tokens)` confirmation line emitted by
+ * `experiences print tokens`. Returns 0 when the line cannot be parsed —
+ * the wizard still records the run; downstream consumers should treat 0 as
+ * "unknown" rather than "no tokens".
+ */
+export declare function parsePrintTokensCount(stdout: string): number;
 export type WizardAppProps = {
     initialSpaceId?: string;
     initialEnvironmentId?: string;
     initialCmaToken?: string;
     initialHost?: string;
     initialAgent?: string;
+    /** Parity-audit Q4: resolved model override (flag || stored value). */
+    initialModel?: string;
     initialProjectPath?: string;
     host?: string;
+    autoAcceptScope?: boolean;
+    noCache?: boolean;
+    autoFilter?: boolean;
+    livePreview?: boolean;
+    noPush?: boolean;
+    noSave?: boolean;
+    /** Task 4 — `--out-dir <path>` flag. Bypasses the inline save-path prompt. */
+    outDirOverride?: string;
+    /**
+     * Task 5 — `--on-conflict <overwrite|skip|fail>` flag. When supplied along
+     * with `outDirOverride`, the wizard skips the SaveConflictGate and applies
+     * the chosen mode automatically via `resolveSavePath`.
+     */
+    onConflictMode?: OnConflictMode;
+    /**
+     * Feature 8: custom prompt path overrides forwarded to the spawned
+     * `analyze select-agent` and `generate components` subprocesses. When set,
+     * the wizard also renders a persistent top-of-screen banner so the operator
+     * cannot miss that bundled invariants are bypassed.
+     */
+    selectPromptPath?: string;
+    generatePromptPath?: string;
+    /**
+     * Modify-entry: when set, the wizard treats extract as already-run and
+     * seeds `state.extractSessionId` from this value. Combined with
+     * `initialStep: 'final-review'`, the wizard skips welcome → token-input →
+     * checking-claude-auth → extracting → scope-gate and lands directly on
+     * the post-generate review screen using DB-backed reads.
+     */
+    seedExtractSessionId?: string;
+    /**
+     * Modify-entry: when set, the wizard treats generate as already-run and
+     * seeds `state.generateSessionId`. Required (together with
+     * `seedExtractSessionId`) for the final-review short-circuit to render
+     * meaningful data.
+     */
+    seedGenerateSessionId?: string;
+    /**
+     * Modify-entry: when set, the wizard treats the tokens step as already-run
+     * and seeds `state.tokenSessionId`. Without this, the modify entry would
+     * leave tokens unaddressable — push would skip them and `runPrintFiles`
+     * would never re-emit `tokens.json` for the modified save path.
+     */
+    seedTokenSessionId?: string;
+    /**
+     * Modify-entry: overrides the wizard's initial step. When set, the wizard
+     * bypasses its normal welcome/token-input bootstrap. Currently only
+     * `'final-review'` is plumbed end-to-end; `'scope-gate'` is accepted for
+     * future use but falls through to standard behavior.
+     */
+    initialStep?: 'scope-gate' | 'final-review';
+    /**
+     * Headless raw-token source path. When set (and the modify-entry props
+     * are not), the wizard seeds `state.rawTokensPath` and lands directly on
+     * the `generating-tokens` step, skipping welcome + token-input. The
+     * existing `generating-tokens` effect then drives token classification
+     * via `generate tokens --raw-tokens <path>` just as if the operator had
+     * submitted the interactive `TokenInputStep`.
+     */
+    initialRawTokensPath?: string;
+    /**
+     * When set with a non-empty array, the wizard opens with the run picker
+     * instead of the welcome step. The picker invokes `onRunPicked` with the
+     * operator's selection so the CLI surface can route into
+     * `--push-from-run` / `--modify` entry points (or fall through to the
+     * normal welcome step on 'new').
+     */
+    initialRuns?: RunRecord[];
+    onRunPicked?: (selection: RunPickerSelection) => void;
 };
-export declare function WizardApp({ initialSpaceId, initialEnvironmentId, initialCmaToken, initialHost, initialAgent, initialProjectPath, host, }?: WizardAppProps): React.ReactElement;
+export declare function WizardApp({ initialSpaceId, initialEnvironmentId, initialCmaToken, initialHost, initialAgent, initialModel, initialProjectPath, host, autoAcceptScope, noCache, autoFilter, livePreview, noPush, noSave, outDirOverride, onConflictMode, selectPromptPath, generatePromptPath, seedExtractSessionId, seedGenerateSessionId, seedTokenSessionId, initialStep, initialRawTokensPath, initialRuns, onRunPicked, }?: WizardAppProps): React.ReactElement;