@contentful/experience-design-system-cli 2.34.5-dev-build-131193c7.0 → 2.34.5-dev-build-a95aeeba.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.34.5-dev-build-131193c7.0",
+  "version": "2.34.5-dev-build-a95aeeba.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

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

@@ -11,6 +11,8 @@ export declare function buildGenerateComponentsArgs(opts: {
     generatePromptPath?: string;
     promptOverrides?: string[];
     existingEntitiesPath?: string;
+    restoreCache?: boolean;
+    cachedComponents?: string[];
 }): string[];
 export declare function buildGenerateTokensArgs(opts: {
     rawTokensPath: string;

package/dist/src/index.js

@@ -110,11 +110,15 @@ var init_credentials_store = __esm({
 var render_with_goodbye_exports = {};
 __export(render_with_goodbye_exports, {
   GoodbyeBoundary: () => GoodbyeBoundary,
-  renderWithGoodbye: () => renderWithGoodbye
+  renderWithGoodbye: () => renderWithGoodbye,
+  useScreenTransitionClear: () => useScreenTransitionClear
 });
-import { useCallback, useEffect, useRef, useState } from "react";
+import { createContext, useCallback, useContext, useEffect, useRef, useState } from "react";
 import { render, Text, useInput } from "ink";
 import { Fragment, jsx } from "react/jsx-runtime";
+function useScreenTransitionClear() {
+  return useContext(ScreenTransitionClearContext);
+}
 function GoodbyeBoundary({ children }) {
   const [isExiting, setIsExiting] = useState(false);
   const isExitingRef = useRef(false);
@@ -138,16 +142,26 @@ function GoodbyeBoundary({ children }) {
   return isExiting ? /* @__PURE__ */ jsx(Text, { children: "Goodbye!" }) : /* @__PURE__ */ jsx(Fragment, { children });
 }
 function renderWithGoodbye(element, options) {
-  return render(/* @__PURE__ */ jsx(GoodbyeBoundary, { children: element }), {
-    ...options,
-    exitOnCtrlC: false
-  });
+  const instanceRef = {};
+  const clearScreen = () => {
+    instanceRef.current?.clear();
+  };
+  const instance = render(
+    /* @__PURE__ */ jsx(ScreenTransitionClearContext.Provider, { value: clearScreen, children: /* @__PURE__ */ jsx(GoodbyeBoundary, { children: element }) }),
+    {
+      ...options,
+      exitOnCtrlC: false
+    }
+  );
+  instanceRef.current = instance;
+  return instance;
 }
-var GOODBYE_RENDER_DELAY_MS;
+var GOODBYE_RENDER_DELAY_MS, ScreenTransitionClearContext;
 var init_render_with_goodbye = __esm({
   "packages/experience-design-system-cli/src/tui/render-with-goodbye.tsx"() {
     "use strict";
     GOODBYE_RENDER_DELAY_MS = 50;
+    ScreenTransitionClearContext = createContext(() => void 0);
   }
 });
 
@@ -1955,8 +1969,7 @@ function hashComponentShape(component) {
     })),
     slots: component.slots.map((s) => ({
       name: s.name,
-      isDefault: s.isDefault,
-      allowedComponents: [...s.allowedComponents ?? []].sort()
+      isDefault: s.isDefault
     }))
   };
   return createHash2("sha256").update(JSON.stringify(payload)).digest("hex");
@@ -3546,15 +3559,38 @@ function lookupCacheByEntity(db, entityType, entityId) {
   };
 }
 function storeCache(db, inputHash, entityType, entityId, sourceSessionId, humanEdited, promptHash = "") {
+  storeCaches(db, [{ inputHash, entityType, entityId, sourceSessionId, humanEdited, promptHash }]);
+}
+function storeCaches(db, entries) {
+  if (entries.length === 0) return;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.prepare(
+  const insert = db.prepare(
     `INSERT INTO generation_cache (input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(input_hash, prompt_hash, entity_type, entity_id) DO UPDATE SET
        source_session_id = excluded.source_session_id,
        human_edited = CASE WHEN generation_cache.human_edited = 1 THEN 1 ELSE excluded.human_edited END,
        updated_at = excluded.updated_at`
-  ).run(inputHash, entityType, entityId, sourceSessionId, humanEdited ? 1 : 0, now, now, promptHash);
+  );
+  db.exec("BEGIN");
+  try {
+    for (const entry of entries) {
+      insert.run(
+        entry.inputHash,
+        entry.entityType,
+        entry.entityId,
+        entry.sourceSessionId,
+        entry.humanEdited ? 1 : 0,
+        now,
+        now,
+        entry.promptHash ?? ""
+      );
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
 }
 function storeScannedFiles(db, sessionId2, filePaths) {
   db.exec("BEGIN");
@@ -3604,9 +3640,9 @@ function loadSlotCycles(db, sessionId2) {
     suggestedBreak: r.suggested_break_json ? JSON.parse(r.suggested_break_json) : null
   }));
 }
-function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentId) {
+function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentId, manageTransaction = true) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.exec("BEGIN");
+  if (manageTransaction) db.exec("BEGIN");
   try {
     const srcComp = db.prepare(
       `SELECT description, status, component_description_rationale, props_rationale, slots_rationale
@@ -3682,6 +3718,19 @@ function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentI
       insertSAC.run(targetSessionId, componentId, sac.slot_name, sac.allowed_component, sac.position);
     }
     db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, targetSessionId);
+    if (manageTransaction) db.exec("COMMIT");
+  } catch (e) {
+    if (manageTransaction) db.exec("ROLLBACK");
+    throw e;
+  }
+}
+function copyComponentsFromCache(db, entries) {
+  if (entries.length === 0) return;
+  db.exec("BEGIN");
+  try {
+    for (const entry of entries) {
+      copyComponentFromCache(db, entry.sourceSessionId, entry.targetSessionId, entry.componentId, false);
+    }
     db.exec("COMMIT");
   } catch (e) {
     db.exec("ROLLBACK");
@@ -4824,43 +4873,41 @@ function printFallbackInstructions(options) {
   lines.push(`  Re-run the generate command with the agent available, or use --dry-run to inspect the prompt.`);
   process.stderr.write(lines.join("\n") + "\n");
 }
-async function runOneComponent(agent, model, db, sessionId2, component, tokensInline, tokenMapInline, index, total, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline) {
+function cachedComponentResult(componentName, warnings = []) {
+  return {
+    componentName,
+    classified: 0,
+    excluded: 0,
+    slots: 0,
+    warnings,
+    failed: false,
+    cached: true,
+    renamedSlotsCount: 0
+  };
+}
+function normalizeComponentForCache(component) {
+  const slots = component.slots.map((slot, index, allSlots) => ({
+    ...slot,
+    name: slot.name.trim() || (allSlots.length === 1 ? "children" : `slot_${index}`)
+  }));
+  return { ...component, slots };
+}
+function lookupComponentCache(db, component, promptHash) {
+  const normalized = normalizeComponentForCache(component);
+  const inputHash = hashComponentShape(normalized);
+  const cached = lookupCache(db, inputHash, "component", component.component_id, promptHash);
+  if (cached) return cached;
+  const legacyInputHash = hashComponentShape(component);
+  return legacyInputHash === inputHash ? null : lookupCache(db, legacyInputHash, "component", component.component_id, promptHash);
+}
+function resolveComponentCache(db, component, promptHash) {
+  const cached = lookupComponentCache(db, component, promptHash);
+  if (cached) return { entry: cached, humanEdited: cached.humanEdited };
+  const pinned = lookupCacheByEntity(db, "component", component.component_id);
+  return pinned?.humanEdited ? { entry: pinned, humanEdited: true } : null;
+}
+async function runOneComponent(agent, model, db, sessionId2, component, tokensInline, tokenMapInline, index, total, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline, precomputedCachedNames) {
   const pos = c.dim(`[${index + 1}/${total}]`);
-  if (!noCache) {
-    const inputHash = hashComponentShape(component);
-    const cached = lookupCache(db, inputHash, "component", component.component_id, promptHash);
-    if (cached) {
-      copyComponentFromCache(db, cached.sourceSessionId, sessionId2, component.component_id);
-      process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.green("cached")}
-`);
-      return {
-        componentName: component.name,
-        classified: 0,
-        excluded: 0,
-        slots: 0,
-        warnings: [],
-        failed: false,
-        cached: true,
-        renamedSlotsCount: 0
-      };
-    }
-    const pinned = lookupCacheByEntity(db, "component", component.component_id);
-    if (pinned?.humanEdited) {
-      copyComponentFromCache(db, pinned.sourceSessionId, sessionId2, component.component_id);
-      process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.cyan("pinned (human-edited)")}
-`);
-      return {
-        componentName: component.name,
-        classified: 0,
-        excluded: 0,
-        slots: 0,
-        warnings: [`${component.name}: source changed but human edits preserved`],
-        failed: false,
-        cached: true,
-        renamedSlotsCount: 0
-      };
-    }
-  }
   const { renames, warnings: renameWarnings } = renameEmptySlots(
     db,
     sessionId2,
@@ -4875,6 +4922,37 @@ async function runOneComponent(agent, model, db, sessionId2, component, tokensIn
     for (const w of renameWarnings) process.stderr.write(`  ${c.yellow("\u26A0")}  ${w}
 `);
   }
+  const cacheComponent = normalizeComponentForCache(component);
+  if (!noCache && precomputedCachedNames.has(component.name)) {
+    process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.green("cached")}
+`);
+    return cachedComponentResult(component.name);
+  }
+  if (!noCache) {
+    const inputHash = hashComponentShape(cacheComponent);
+    const resolution = resolveComponentCache(db, component, promptHash);
+    if (resolution && !resolution.humanEdited) {
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id);
+      storeCache(
+        db,
+        inputHash,
+        "component",
+        component.component_id,
+        resolution.entry.sourceSessionId,
+        resolution.entry.humanEdited,
+        promptHash
+      );
+      process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.green("cached")}
+`);
+      return cachedComponentResult(component.name);
+    }
+    if (resolution?.humanEdited) {
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id);
+      process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.cyan("pinned (human-edited)")}
+`);
+      return cachedComponentResult(component.name, [`${component.name}: source changed but human edits preserved`]);
+    }
+  }
   const rawComponentsInline = JSON.stringify(
     [
       {
@@ -4944,7 +5022,7 @@ ${outputBuf}`);
     }
     const applied = applyToolCalls(db, sessionId2, component.component_id, component.name, calls, warnings);
     if (!noCache) {
-      const inputHash = hashComponentShape(component);
+      const inputHash = hashComponentShape(cacheComponent);
       storeCache(db, inputHash, "component", component.component_id, sessionId2, false, promptHash);
     }
     return {
@@ -4968,7 +5046,7 @@ ${outputBuf}`);
     renamedSlotsCount: renames.length
   };
 }
-async function runAllComponents(agent, model, db, sessionId2, components, tokensInline, tokenMapInline, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline) {
+async function runAllComponents(agent, model, db, sessionId2, components, tokensInline, tokenMapInline, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline, precomputedCachedNames) {
   const concurrency = Number(process.env.EDS_GENERATE_CONCURRENCY ?? DEFAULT_COMPONENT_CONCURRENCY);
   process.stderr.write(
     `Categorizing ${c.bold(String(components.length))} component${components.length === 1 ? "" : "s"}` + c.dim(`  (concurrency: ${concurrency})`) + "\n"
@@ -4995,7 +5073,8 @@ async function runAllComponents(agent, model, db, sessionId2, components, tokens
         skillContentOverride,
         promptHash,
         existingContentfulEntities,
-        existingTokensInline
+        existingTokensInline,
+        precomputedCachedNames
       );
       completed += 1;
       process.stderr.write(`${formatGenerateProgressLine(completed, components.length, results[i].componentName)}
@@ -5024,6 +5103,15 @@ async function loadAcceptedNames(sessionId2) {
     return null;
   }
 }
+function parsePrecomputedCachedNames(value) {
+  if (!value) return /* @__PURE__ */ new Set();
+  try {
+    const parsed = JSON.parse(value);
+    return new Set(Array.isArray(parsed) ? parsed.filter((name) => typeof name === "string") : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
 async function runGenerateSkill(skill, opts, verbose = false) {
   const savedCreds = await readExperiencesCredentials();
   const agentName = opts.agent ?? savedCreds.agent;
@@ -5178,6 +5266,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
   if (skill === "components" && allComponents && sessionId2) {
     const db = openPipelineDb();
     let componentResults;
+    const precomputedCachedNames = parsePrecomputedCachedNames(opts.cachedComponents);
     try {
       const existingContentfulEntitiesHashInputs = [];
       if (existingTokensInline) existingContentfulEntitiesHashInputs.push(hashContent(existingTokensInline));
@@ -5189,6 +5278,52 @@ async function runGenerateSkill(skill, opts, verbose = false) {
         existingContentfulEntitiesHashInputs,
         generatePrompt
       );
+      if (opts.cacheStatus) {
+        const cacheEnabled = opts.cache !== false && process.env.EDS_NO_CACHE !== "1";
+        const cachedComponents = cacheEnabled ? allComponents.flatMap((component) => {
+          const resolution = resolveComponentCache(db, component, promptHash);
+          return resolution ? [{ component, resolution }] : [];
+        }) : [];
+        if (cacheEnabled && opts.restoreCache) {
+          const restorations = [];
+          const rekeyed = [];
+          const componentStatus = db.prepare(
+            "SELECT status FROM raw_components WHERE session_id = ? AND component_id = ?"
+          );
+          for (const { component, resolution } of cachedComponents) {
+            const current = componentStatus.get(sessionId2, component.component_id);
+            if (current?.status === "generated") continue;
+            renameEmptySlots(db, sessionId2, component.component_id, component.name, component.slots.length);
+            restorations.push({
+              sourceSessionId: resolution.entry.sourceSessionId,
+              targetSessionId: sessionId2,
+              componentId: component.component_id
+            });
+            rekeyed.push({ component, cached: resolution.entry });
+          }
+          copyComponentsFromCache(db, restorations);
+          storeCaches(
+            db,
+            rekeyed.map(({ component, cached }) => ({
+              inputHash: hashComponentShape(normalizeComponentForCache(component)),
+              entityType: "component",
+              entityId: component.component_id,
+              sourceSessionId: cached.sourceSessionId,
+              humanEdited: cached.humanEdited,
+              promptHash
+            }))
+          );
+        }
+        const fullyCached = cacheEnabled && cachedComponents.length === allComponents.length;
+        process.stdout.write(`cache-status=${fullyCached ? "hit" : "miss"}
+`);
+        process.stdout.write(
+          `cache-components=${JSON.stringify(cachedComponents.map(({ component }) => component.name))}
+`
+        );
+        await exitWithAnalytics(0);
+        return;
+      }
       componentResults = await runAllComponents(
         agent,
         model,
@@ -5203,7 +5338,8 @@ async function runGenerateSkill(skill, opts, verbose = false) {
         generatePrompt,
         promptHash,
         existingContentfulEntities,
-        existingTokensInline
+        existingTokensInline,
+        precomputedCachedNames
       );
     } finally {
       db.close();
@@ -5389,6 +5525,12 @@ function registerInternalGenerateCommand(program) {
     "--existing-entities-path <path>",
     "Path to the .existing-entities.json file written after CMA credentials are supplied. When present, per-component prompts include a summary of the target space so classifications can align to existing prop names/tokens. Missing/malformed files are treated as no-op."
   );
+  componentsCmd.option("--cache-status", "Check whether all selected component definitions are cached");
+  componentsCmd.option("--restore-cache", "Restore cached component definitions into the current session");
+  componentsCmd.option(
+    "--cached-components <json>",
+    "Component names already restored by a prior cache-status lookup; skip per-component cache lookup"
+  );
   addAgentFlags(componentsCmd).action(async (opts) => {
     await runGenerateSkill("components", opts, opts.verbose ?? false);
   });
@@ -26590,10 +26732,31 @@ var init_GenerateReviewStep = __esm({
 
 // packages/experience-design-system-cli/src/import/tui/runScopeGate.ts
 async function runScopeGate(opts) {
+  const startedAt = Date.now();
+  getDebugLogger().event("wizard", "scope-decision-persistence.start", {
+    sessionId: opts.sessionId,
+    acceptedCount: opts.decisions.accepted.length,
+    rejectedCount: opts.decisions.rejected.length
+  });
   const db = openPipelineDb();
   try {
     applyScopeDecisions(db, opts.sessionId, opts.decisions);
     await writeScopeDecisionsSnapshot(db, opts.sessionId, opts.decisions);
+    getDebugLogger().event("wizard", "scope-decision-persistence.complete", {
+      sessionId: opts.sessionId,
+      acceptedCount: opts.decisions.accepted.length,
+      rejectedCount: opts.decisions.rejected.length,
+      durationMs: Date.now() - startedAt
+    });
+  } catch (error) {
+    getDebugLogger().event("wizard", "scope-decision-persistence.error", {
+      sessionId: opts.sessionId,
+      acceptedCount: opts.decisions.accepted.length,
+      rejectedCount: opts.decisions.rejected.length,
+      durationMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
   } finally {
     db.close();
   }
@@ -26607,6 +26770,7 @@ var init_runScopeGate = __esm({
   "packages/experience-design-system-cli/src/import/tui/runScopeGate.ts"() {
     "use strict";
     init_persistence();
+    init_debug_logger();
     init_db();
   }
 });
@@ -26860,6 +27024,10 @@ function buildGenerateComponentsArgs(opts) {
   if (opts.generatePromptPath) args.push("--generate-prompt-path", opts.generatePromptPath);
   for (const prompt of opts.promptOverrides ?? []) args.push("--prompt", prompt);
   if (opts.existingEntitiesPath) args.push("--existing-entities-path", opts.existingEntitiesPath);
+  if (opts.restoreCache) args.push("--restore-cache");
+  if (opts.cachedComponents && opts.cachedComponents.length > 0) {
+    args.push("--cached-components", JSON.stringify(opts.cachedComponents));
+  }
   return args;
 }
 function buildGenerateTokensArgs(opts) {
@@ -26943,6 +27111,17 @@ function logStep(entry) {
   appendFileSync2(WIZARD_LOG, line);
   getDebugLogger().event("wizard", "step", entry);
 }
+function startWizardTimer(name, payload = {}) {
+  const startedAt = Date.now();
+  getDebugLogger().event("wizard", `${name}.start`, payload);
+  return startedAt;
+}
+function finishWizardTimer(name, startedAt, payload = {}) {
+  getDebugLogger().event("wizard", `${name}.complete`, {
+    ...payload,
+    durationMs: Date.now() - startedAt
+  });
+}
 function WizardApp({
   initialSpaceId = "",
   initialEnvironmentId = "master",
@@ -26965,6 +27144,7 @@ function WizardApp({
   const resolveWizardHost = (hostValue) => hostValue || defaultConfiguredHost;
   const credentialKey = (spaceId, environmentId, cmaToken, hostValue) => [spaceId.trim(), environmentId.trim(), cmaToken.trim(), resolveWizardHost(hostValue)].join("\0");
   const { columns: terminalWidth } = useTerminalSize();
+  const clearScreenOnTransition = useScreenTransitionClear();
   const logInit = useRef10(false);
   const initialAgentAuthRef = useRef10(initialAgentAuth ?? null);
   if (!logInit.current) {
@@ -26978,6 +27158,8 @@ function WizardApp({
   });
   const allowEmptyDeleteAllRef = useRef10(false);
   const generateChildRef = useRef10(null);
+  const generationCachePreflightRef = useRef10(null);
+  const selectionToReviewStartedAtRef = useRef10(null);
   const credentialsValidationIdRef = useRef10(0);
   const pendingCredentialValidationRef = useRef10(null);
   const validatedCredentialsKeyRef = useRef10(null);
@@ -26985,6 +27167,7 @@ function WizardApp({
   const extractPromiseRef = useRef10(null);
   const extractStartedRef = useRef10(false);
   const credentialsReadyRef = useRef10(false);
+  const agentAuthVerifiedRef = useRef10(false);
   const scopeGateCompletedRef = useRef10(false);
   const existingEntitiesPromiseRef = useRef10(null);
   const generatePromiseRef = useRef10(null);
@@ -27055,7 +27238,10 @@ function WizardApp({
       tokensPath: state.tokensPath
     };
   }, [state.extractSessionId, state.tokensPath]);
-  const update = (partial) => {
+  const update = (partial, options = {}) => {
+    if (partial.step !== void 0 && partial.step !== state.step && options.clearScreen !== false) {
+      clearScreenOnTransition();
+    }
     const sanitized = { ...partial };
     if (sanitized.serverPreview) {
       const p = sanitized.serverPreview;
@@ -27102,12 +27288,41 @@ function WizardApp({
     logStep({ update: sanitized });
     setState((prev) => ({ ...prev, ...partial }));
   };
-  const runAgentAuthCheck = async (nextStep) => {
+  const finishSelectionToReviewTimer = (mode) => {
+    const startedAt = selectionToReviewStartedAtRef.current;
+    if (startedAt === null) return;
+    selectionToReviewStartedAtRef.current = null;
+    finishWizardTimer("selection-to-review", startedAt, { mode });
+  };
+  const runAgentAuthCheck = async (nextStep, deferStep = false) => {
+    const timer = startWizardTimer("agent-auth-validation", {
+      agent: state.agent,
+      deferred: deferStep,
+      nextStep
+    });
+    if (agentAuthVerifiedRef.current) {
+      finishWizardTimer("agent-auth-validation", timer, { status: "already-verified" });
+      if (!deferStep) update({ step: nextStep });
+      return true;
+    }
     const authCheckStepNumber = state.tokensPath ? 4 : 3;
     const prefetchedAuth = initialAgentAuthRef.current;
     initialAgentAuthRef.current = null;
-    if (!prefetchedAuth) update({ step: "checking-claude-auth", authCheckStepNumber });
-    const status = await (prefetchedAuth ?? checkAgentAuth(state.agent));
+    if (!prefetchedAuth && !deferStep) update({ step: "checking-claude-auth", authCheckStepNumber });
+    let status;
+    try {
+      status = await (prefetchedAuth ?? checkAgentAuth(state.agent));
+    } catch (error) {
+      finishWizardTimer("agent-auth-validation", timer, {
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+    finishWizardTimer("agent-auth-validation", timer, {
+      status,
+      prefetched: Boolean(prefetchedAuth)
+    });
     if (status === "not-found") {
       update({
         step: "error",
@@ -27131,7 +27346,8 @@ If you are using AWS Bedrock, run:
       });
       return false;
     }
-    update({ step: nextStep });
+    agentAuthVerifiedRef.current = true;
+    if (!deferStep) update({ step: nextStep });
     return true;
   };
   const runGenerateTokens = async (rawTokensPath, outDir, forceRegenerate = false) => {
@@ -27186,7 +27402,13 @@ If you are using AWS Bedrock, run:
     update({ tokensPath, tokenSessionId, tokenCount, tokenGenerationStatus: "complete" });
     return true;
   };
-  const runMapTokens2 = async (sessionId2) => {
+  const runMapTokens2 = async (sessionId2, silent = false) => {
+    const timer = startWizardTimer("token-mapping", {
+      sessionId: sessionId2,
+      silent,
+      noCache: effectiveNoCache,
+      skipAgent: skipMapTokens
+    });
     let mappablePropCount = 0;
     let rawTokenCount = 0;
     try {
@@ -27213,13 +27435,22 @@ If you are using AWS Bedrock, run:
         errorStep: "map tokens",
         errorMessage: error instanceof Error ? error.message : String(error)
       });
+      finishWizardTimer("token-mapping", timer, {
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
       return false;
     }
     if (!shouldRunMapTokens({ mappablePropCount, rawTokenCount })) {
-      update({ mapTokensEligible: false, mapTokensStatus: "complete" });
+      if (!silent) update({ mapTokensEligible: false, mapTokensStatus: "complete" });
+      finishWizardTimer("token-mapping", timer, {
+        status: "skipped",
+        mappablePropCount,
+        rawTokenCount
+      });
       return true;
     }
-    update({ mapTokensEligible: true, mapTokensStatus: "running" });
+    if (!silent) update({ mapTokensEligible: true, mapTokensStatus: "running", step: "generating" });
     const args = buildMapTokensArgs({
       sessionId: sessionId2,
       agent: state.agent,
@@ -27237,9 +27468,21 @@ If you are using AWS Bedrock, run:
         errorStep: "map tokens",
         errorMessage: result.stderr.trim() || "Unknown error"
       });
+      finishWizardTimer("token-mapping", timer, {
+        status: "error",
+        exitCode: result.exitCode,
+        mappablePropCount,
+        rawTokenCount
+      });
       return false;
     }
-    update({ mapTokensStatus: "complete" });
+    if (!silent) update({ mapTokensStatus: "complete" });
+    finishWizardTimer("token-mapping", timer, {
+      status: "complete",
+      exitCode: result.exitCode,
+      mappablePropCount,
+      rawTokenCount
+    });
     return true;
   };
   const startExistingEntitiesFetch = (projectPath, outDir) => {
@@ -27489,7 +27732,7 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
       generateProgress: null
     }));
   };
-  const buildGenerateArgs = (extractSessionId, tokensPath, generatePromptPath2) => buildGenerateProcessArgs({
+  const buildGenerateOptions = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => ({
     sessionId: extractSessionId,
     tokensPath,
     agent: state.agent,
@@ -27498,8 +27741,127 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
     noCache: effectiveNoCache,
     ...state.existingEntitiesPath ? { existingEntitiesPath: state.existingEntitiesPath } : {},
     ...generatePromptPath2 ? { generatePromptPath: generatePromptPath2 } : {},
-    promptOverrides
+    promptOverrides,
+    ...cachedComponents && cachedComponents.length > 0 ? { cachedComponents } : {}
   });
+  const buildGenerateArgs = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => buildGenerateProcessArgs(buildGenerateOptions(extractSessionId, tokensPath, generatePromptPath2, cachedComponents));
+  const buildGenerateCliArgs = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => buildGenerateComponentsArgs(
+    buildGenerateOptions(extractSessionId, tokensPath, generatePromptPath2, cachedComponents)
+  );
+  const checkGenerateCache = async (extractSessionId, tokensPath) => {
+    const timer = startWizardTimer("generation-cache-status", {
+      sessionId: extractSessionId,
+      noCache: effectiveNoCache
+    });
+    if (effectiveNoCache) {
+      finishWizardTimer("generation-cache-status", timer, { status: "skipped" });
+      return false;
+    }
+    const result = await runCli([...buildGenerateCliArgs(extractSessionId, tokensPath), "--cache-status"]);
+    const hit = result.exitCode === 0 && /^cache-status=hit$/m.test(result.stdout);
+    finishWizardTimer("generation-cache-status", timer, {
+      status: hit ? "hit" : "miss",
+      exitCode: result.exitCode,
+      ...result.exitCode !== 0 ? { stderrTail: result.stderr.trim().slice(-500) } : {}
+    });
+    return hit;
+  };
+  const checkGenerateCacheComponents = async (extractSessionId, tokensPath, restoreCache = false) => {
+    const timer = startWizardTimer("generation-cache-components", {
+      sessionId: extractSessionId,
+      restoreCache,
+      noCache: effectiveNoCache
+    });
+    if (effectiveNoCache) {
+      finishWizardTimer("generation-cache-components", timer, { status: "skipped" });
+      return /* @__PURE__ */ new Set();
+    }
+    const args = [...buildGenerateCliArgs(extractSessionId, tokensPath), "--cache-status"];
+    if (restoreCache) args.push("--restore-cache");
+    const result = await runCli(args);
+    if (result.exitCode !== 0) {
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "error",
+        exitCode: result.exitCode,
+        stderrTail: result.stderr.trim().slice(-500)
+      });
+      return /* @__PURE__ */ new Set();
+    }
+    const line = /^cache-components=(.+)$/m.exec(result.stdout)?.[1];
+    if (!line) {
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "missing-output",
+        exitCode: result.exitCode,
+        cachedCount: 0
+      });
+      return /* @__PURE__ */ new Set();
+    }
+    try {
+      const names = JSON.parse(line);
+      const cachedNames = new Set(
+        Array.isArray(names) ? names.filter((name) => typeof name === "string") : []
+      );
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "complete",
+        exitCode: result.exitCode,
+        cachedCount: cachedNames.size
+      });
+      return cachedNames;
+    } catch {
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "invalid-output",
+        exitCode: result.exitCode,
+        cachedCount: 0
+      });
+      return /* @__PURE__ */ new Set();
+    }
+  };
+  useEffect15(() => {
+    if (state.step !== "extracting" && state.step !== "scope-gate" || !state.extractSessionId || state.existingEntitiesStatus === "running" || state.existingEntitiesStatus === "idle" || state.selectionAgentStatus !== "complete" || state.compositionPhase !== "done" && state.compositionPhase !== "cache-hit" || state.rawTokensPath && state.tokenGenerationStatus !== "complete" || effectiveNoCache) {
+      return;
+    }
+    const sessionId2 = state.extractSessionId;
+    if (generationCachePreflightRef.current?.sessionId === sessionId2) return;
+    const timer = startWizardTimer("generation-cache-preflight", { sessionId: sessionId2 });
+    const db = openPipelineDb();
+    let generatedNames = null;
+    try {
+      const rows = db.prepare("SELECT name, status FROM raw_components WHERE session_id = ?").all(sessionId2);
+      if (rows.length > 0 && rows.every((row) => row.status === "generated")) {
+        generatedNames = new Set(rows.map((row) => row.name));
+      }
+    } finally {
+      db.close();
+    }
+    if (generatedNames) {
+      generationCachePreflightRef.current = { sessionId: sessionId2, promise: Promise.resolve(generatedNames) };
+      finishWizardTimer("generation-cache-preflight", timer, {
+        status: "complete",
+        source: "session-db",
+        cachedCount: generatedNames.size
+      });
+      return;
+    }
+    const promise = checkGenerateCacheComponents(sessionId2, state.tokensPath, true);
+    generationCachePreflightRef.current = { sessionId: sessionId2, promise };
+    void promise.then((cachedNames) => {
+      finishWizardTimer("generation-cache-preflight", timer, {
+        status: "complete",
+        source: "cache-status",
+        cachedCount: cachedNames.size
+      });
+    });
+  }, [
+    state.step,
+    state.extractSessionId,
+    state.tokensPath,
+    state.rawTokensPath,
+    state.tokenGenerationStatus,
+    state.selectionAgentStatus,
+    state.compositionPhase,
+    state.existingEntitiesStatus,
+    state.existingEntitiesPath
+  ]);
   const startGeneratePrefetch = (extractSessionId, tokensPath) => {
     const args = buildGenerateArgs(extractSessionId, tokensPath);
     let progressCursor = null;
@@ -27554,8 +27916,14 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
     });
     return donePromise;
   };
-  const runGenerate = async (extractSessionId, tokensPath, acceptedCount) => {
-    const args = buildGenerateArgs(extractSessionId, tokensPath, generatePromptPath);
+  const runGenerate = async (extractSessionId, tokensPath, acceptedCount, suppressScreen = false, cachedComponents = []) => {
+    const timer = startWizardTimer("component-generation", {
+      sessionId: extractSessionId,
+      acceptedCount,
+      suppressScreen,
+      noCache: effectiveNoCache
+    });
+    const args = buildGenerateArgs(extractSessionId, tokensPath, generatePromptPath, cachedComponents);
     let progressCursor = state.generateProgress;
     const { donePromise } = spawnGenerateChild({
       command: "node",
@@ -27564,12 +27932,17 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
         const nextProgress = parseGenerateStderrChunk(chunk, progressCursor);
         if (nextProgress !== progressCursor) {
           progressCursor = nextProgress;
-          update({ generateProgress: nextProgress });
+          if (!suppressScreen) update({ generateProgress: nextProgress });
         }
       }
     });
     const result = await donePromise;
     if (result.exitCode !== 0) {
+      finishWizardTimer("component-generation", timer, {
+        status: "error",
+        exitCode: result.exitCode
+      });
+      finishSelectionToReviewTimer("error");
       update({
         step: "error",
         errorStep: "generate components",
@@ -27577,14 +27950,67 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
       });
       return;
     }
-    const { generateSessionId: generateSessionId2, generatedCount } = parseGenerateResult(result, acceptedCount);
+    const { generateSessionId: generateSessionId2, generatedCount, renamedSlotsCount } = parseGenerateResult(result, acceptedCount);
     const mappedSessionId = generateSessionId2 ?? extractSessionId;
-    update({
-      generateSessionId: mappedSessionId,
+    finishWizardTimer("component-generation", timer, {
+      status: "complete",
+      exitCode: result.exitCode,
       generatedCount,
-      generateProgress: null
+      renamedSlotsCount
     });
-    if (await runMapTokens2(mappedSessionId)) update({ step: "final-review" });
+    if (!suppressScreen) {
+      update({
+        acceptedCount,
+        autoRejectedCount: 0,
+        generateSessionId: mappedSessionId,
+        generatedCount,
+        generateProgress: null
+      });
+      if (await runMapTokens2(mappedSessionId)) {
+        finishSelectionToReviewTimer("generated");
+        update({ step: "final-review" });
+      } else {
+        finishSelectionToReviewTimer("error");
+      }
+      return;
+    }
+    const mapped = await runMapTokens2(mappedSessionId, true);
+    if (mapped) {
+      finishSelectionToReviewTimer("generated");
+      update(
+        {
+          acceptedCount,
+          autoRejectedCount: 0,
+          generateSessionId: mappedSessionId,
+          generatedCount,
+          generateProgress: null,
+          mapTokensStatus: "complete",
+          step: "final-review"
+        },
+        { clearScreen: false }
+      );
+    } else {
+      finishSelectionToReviewTimer("error");
+    }
+  };
+  const finishCachedGeneration = async (sessionId2, acceptedCount) => {
+    if (await runMapTokens2(sessionId2, true)) {
+      finishSelectionToReviewTimer("cached");
+      update(
+        {
+          acceptedCount,
+          autoRejectedCount: 0,
+          generateSessionId: sessionId2,
+          generatedCount: acceptedCount,
+          generateProgress: null,
+          mapTokensStatus: "complete",
+          step: "final-review"
+        },
+        { clearScreen: false }
+      );
+    } else {
+      finishSelectionToReviewTimer("error");
+    }
   };
   const advanceToPushFlow = (generatedAcceptedCount) => {
     update({ generatedAcceptedCount });
@@ -27769,8 +28195,15 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
           return;
         }
       }
-      if (await runAgentAuthCheck("generating")) {
-        void runGenerate(sid, state.tokensPath, state.acceptedCount);
+      if (await runAgentAuthCheck("generating", true)) {
+        const cacheHit = await checkGenerateCache(sid, state.tokensPath);
+        if (cacheHit) {
+          update({ step: "generating" });
+          void finishCachedGeneration(sid, state.acceptedCount);
+        } else {
+          update({ step: "generating" });
+          void runGenerate(sid, state.tokensPath, state.acceptedCount);
+        }
       }
       return;
     }
@@ -28138,13 +28571,13 @@ If using a custom host configuration, make sure the space exists on that host.`
     update(nextStateAfterPrint({ skipGate: opts.skipGate, componentsPath }));
     return { ok: true };
   };
-  const runSaveAndPush = async () => {
-    await startSaveFlow({ skipGate: true, andPush: true });
+  const runSaveAndPush = async (statePatch = {}) => {
+    await startSaveFlow({ skipGate: true, andPush: true }, statePatch);
   };
   const pendingSaveOptionsRef = useRef10({});
-  const startSaveFlow = async (opts = {}) => {
+  const startSaveFlow = async (opts = {}, statePatch = {}) => {
     pendingSaveOptionsRef.current = opts;
-    setState((prev) => ({ ...prev, step: "path-prompt" }));
+    update({ ...statePatch, step: "path-prompt" });
   };
   const proceedToWrite = async (path) => {
     setState((prev) => ({ ...prev, outDir: path }));
@@ -28387,31 +28820,86 @@ If using a custom host configuration, make sure the space exists on that host.`
           {
             components,
             onConfirm: (decisions) => {
-              void runScopeGate({
-                sessionId: sessionId2,
-                decisions,
-                onAdvanceToGenerate: async ({ sessionId: sid, acceptedCount }) => {
-                  scopeGateCompletedRef.current = true;
-                  if (shouldGenerateAfterScopeGate({ acceptedCount })) {
-                    update({
-                      acceptedCount,
-                      autoRejectedCount: 0,
-                      step: "checking-claude-auth",
-                      authCheckStepNumber: state.tokensPath ? 4 : 3
-                    });
-                    if (await runAgentAuthCheck("generating")) {
-                      void runGenerate(sid, state.tokensPath, acceptedCount);
+              void (async () => {
+                selectionToReviewStartedAtRef.current = decisions.accepted.length > 0 ? startWizardTimer("selection-to-review", {
+                  sessionId: sessionId2,
+                  acceptedCount: decisions.accepted.length,
+                  rejectedCount: decisions.rejected.length
+                }) : null;
+                const preflight = generationCachePreflightRef.current;
+                const cachePromise = preflight?.sessionId === sessionId2 ? preflight.promise : checkGenerateCacheComponents(sessionId2, state.tokensPath, true);
+                if (!preflight || preflight.sessionId !== sessionId2) {
+                  generationCachePreflightRef.current = { sessionId: sessionId2, promise: cachePromise };
+                }
+                const cacheWaitStartedAt = startWizardTimer("selection-cache-restoration-wait", {
+                  sessionId: sessionId2,
+                  preflight: Boolean(preflight?.sessionId === sessionId2)
+                });
+                try {
+                  const cachedNames = await cachePromise;
+                  finishWizardTimer("selection-cache-restoration-wait", cacheWaitStartedAt, {
+                    status: "complete",
+                    cachedCount: cachedNames.size
+                  });
+                } catch (error) {
+                  finishWizardTimer("selection-cache-restoration-wait", cacheWaitStartedAt, {
+                    status: "error",
+                    error: error instanceof Error ? error.message : String(error)
+                  });
+                  finishSelectionToReviewTimer("error");
+                  throw error;
+                }
+                await runScopeGate({
+                  sessionId: sessionId2,
+                  decisions,
+                  onAdvanceToGenerate: async ({ sessionId: sid, acceptedCount }) => {
+                    scopeGateCompletedRef.current = true;
+                    if (shouldGenerateAfterScopeGate({ acceptedCount })) {
+                      const authPromise = runAgentAuthCheck("generating", true);
+                      if (await authPromise) {
+                        const comparisonStartedAt = startWizardTimer("generation-cache-set-comparison", {
+                          sessionId: sid,
+                          acceptedCount: decisions?.accepted.length ?? 0
+                        });
+                        let cachedNames = await cachePromise;
+                        const acceptedNames = decisions?.accepted ?? [];
+                        let cacheHit = !effectiveNoCache && acceptedNames.length > 0 && acceptedNames.every((name) => cachedNames.has(name));
+                        if (!cacheHit && !effectiveNoCache && acceptedNames.length > 0) {
+                          cachedNames = await checkGenerateCacheComponents(sid, state.tokensPath, true);
+                          cacheHit = acceptedNames.every((name) => cachedNames.has(name));
+                        }
+                        finishWizardTimer("generation-cache-set-comparison", comparisonStartedAt, {
+                          status: "complete",
+                          cacheHit,
+                          cachedCount: cachedNames.size,
+                          acceptedCount: acceptedNames.length
+                        });
+                        if (cacheHit) {
+                          void finishCachedGeneration(sid, acceptedCount);
+                        } else {
+                          const acceptedNameSet = new Set(acceptedNames);
+                          const restoredCachedNames = [...cachedNames].filter((name) => acceptedNameSet.has(name));
+                          update({
+                            step: "generating",
+                            generateProgress: null,
+                            acceptedCount
+                          });
+                          void runGenerate(sid, state.tokensPath, acceptedCount, false, restoredCachedNames);
+                        }
+                      } else {
+                        finishSelectionToReviewTimer("error");
+                      }
+                      return;
                     }
-                    return;
+                    void runSaveAndPush();
+                  },
+                  onAdvanceToPushFlow: (count) => {
+                    scopeGateCompletedRef.current = true;
+                    update({ acceptedCount: count, autoRejectedCount: 0 });
+                    advanceToPushFlow(count);
                   }
-                  void runSaveAndPush();
-                },
-                onAdvanceToPushFlow: (count) => {
-                  scopeGateCompletedRef.current = true;
-                  update({ acceptedCount: count, autoRejectedCount: 0 });
-                  advanceToPushFlow(count);
-                }
-              });
+                });
+              })();
             },
             onQuit: () => process.exit(0)
           }
@@ -28498,8 +28986,10 @@ If using a custom host configuration, make sure the space exists on that host.`
               }
               const allowEmptyDeleteAll = acceptedCount === 0;
               allowEmptyDeleteAllRef.current = allowEmptyDeleteAll;
-              update({ finalReviewPassed: true, generatedAcceptedCount: acceptedCount });
-              void runSaveAndPush();
+              void runSaveAndPush({
+                finalReviewPassed: true,
+                generatedAcceptedCount: acceptedCount
+              });
             },
             onQuit: () => process.exit(0)
           }
@@ -28738,6 +29228,7 @@ var init_WizardApp = __esm({
     init_prompt_overrides();
     init_run_selection_agent();
     init_use_terminal_size();
+    init_render_with_goodbye();
     SAVE_CONFIRMATION_DELAY_MS = 1e3;
     WIZARD_LOG = join20(tmpdir(), "experiences-import-wizard.log");
   }

package/dist/src/session/db.d.ts

@@ -122,6 +122,14 @@ export declare function computeMapTokensInputHash(db: DatabaseSync, sessionId: s
 export declare function lookupCache(db: DatabaseSync, inputHash: string, entityType: CacheEntityType, entityId: string, promptHash?: string): CacheEntry | null;
 export declare function lookupCacheByEntity(db: DatabaseSync, entityType: CacheEntityType, entityId: string): CacheEntry | null;
 export declare function storeCache(db: DatabaseSync, inputHash: string, entityType: CacheEntityType, entityId: string, sourceSessionId: string, humanEdited: boolean, promptHash?: string): void;
+export declare function storeCaches(db: DatabaseSync, entries: Array<{
+    inputHash: string;
+    entityType: CacheEntityType;
+    entityId: string;
+    sourceSessionId: string;
+    humanEdited: boolean;
+    promptHash?: string;
+}>): void;
 export declare function storeScannedFiles(db: DatabaseSync, sessionId: string, filePaths: string[]): void;
 export declare function loadScannedFiles(db: DatabaseSync, sessionId: string): string[];
 export declare function storeSlotCycles(db: DatabaseSync, sessionId: string, cycles: Array<SlotCycle & {
@@ -133,7 +141,12 @@ export interface StoredSlotCycle extends SlotCycle {
 export declare function loadSlotCycles(db: DatabaseSync, sessionId: string): StoredSlotCycle[];
 export declare function clearSlotCycles(db: DatabaseSync, sessionId: string): void;
 export declare function markCacheHumanEdited(db: DatabaseSync, entityType: 'component' | 'token_set', entityId: string): void;
-export declare function copyComponentFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string, componentId: string): void;
+export declare function copyComponentFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string, componentId: string, manageTransaction?: boolean): void;
+export declare function copyComponentsFromCache(db: DatabaseSync, entries: Array<{
+    sourceSessionId: string;
+    targetSessionId: string;
+    componentId: string;
+}>): void;
 export declare function copyTokensFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string): void;
 export declare function copyMapTokensFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string): number;
 export declare function getCliCacheVersion(): Promise<string>;

package/dist/src/tui/render-with-goodbye.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import { type Instance, type RenderOptions } from 'ink';
+export declare function useScreenTransitionClear(): () => void;
 export declare function GoodbyeBoundary({ children }: {
     children: React.ReactNode;
 }): React.ReactElement;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.34.5-dev-build-131193c7.0",
+  "version": "2.34.5-dev-build-a95aeeba.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -41,8 +41,8 @@
     "svelte": "^5.56.4",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3",
-    "@contentful/experience-design-system-cli-v2": "2.34.5-dev-build-131193c7.0",
-    "@contentful/experience-design-system-types": "2.34.5-dev-build-131193c7.0"
+    "@contentful/experience-design-system-types": "2.34.5-dev-build-a95aeeba.0",
+    "@contentful/experience-design-system-cli-v2": "2.34.5-dev-build-a95aeeba.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.4",
@@ -54,9 +54,9 @@
     "ink-testing-library": "^4.0.0",
     "typescript-eslint": "^8.67.0",
     "vitest": "^4.0.16",
-    "@contentful/experience-design-system-extraction": "2.34.5-dev-build-131193c7.0",
-    "@contentful/experience-design-system-generation": "2.34.5-dev-build-131193c7.0",
-    "@contentful/experience-design-system-client": "2.34.5-dev-build-131193c7.0"
+    "@contentful/experience-design-system-extraction": "2.34.5-dev-build-a95aeeba.0",
+    "@contentful/experience-design-system-client": "2.34.5-dev-build-a95aeeba.0",
+    "@contentful/experience-design-system-generation": "2.34.5-dev-build-a95aeeba.0"
   },
   "repository": {
     "type": "git",