@contentful/experience-design-system-cli 2.37.1-dev-build-fb8573b6.0 → 2.37.1-dev-build-799db3ac.0

package/legacy/dist/src/index.js

@@ -4163,6 +4163,34 @@ function lookupCompositionCache(db, inputHash, cliVersion2) {
   const row = db.prepare(`SELECT agent_output FROM composition_cache WHERE input_hash = ? AND cli_version = ?`).get(inputHash, cliVersion2);
   return row ? row.agent_output : null;
 }
+function storeSelectCache(db, componentHash, promptHash, cliVersion2, decision, reason) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO select_cache (component_hash, prompt_hash, cli_version, decision, reason, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(component_hash, prompt_hash, cli_version) DO UPDATE SET
+       decision = excluded.decision,
+       reason = excluded.reason,
+       updated_at = excluded.updated_at`
+  ).run(componentHash, promptHash, cliVersion2, decision, reason, now, now);
+}
+function lookupSelectCache(db, componentHash, promptHash, cliVersion2) {
+  const row = db.prepare(
+    `SELECT component_hash, prompt_hash, cli_version, decision, reason, created_at, updated_at
+       FROM select_cache
+       WHERE component_hash = ? AND prompt_hash = ? AND cli_version = ?`
+  ).get(componentHash, promptHash, cliVersion2);
+  if (!row) return null;
+  return {
+    componentHash: row.component_hash,
+    promptHash: row.prompt_hash,
+    cliVersion: row.cli_version,
+    decision: row.decision,
+    reason: row.reason,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
 var SCHEMA, MAX_COMPONENT_SOURCE_CHARS, MAX_SIBLING_FILES, MAX_SIBLING_SNIPPET_CHARS, MAX_TYPE_DECLARING_SIBLING_CHARS, MAX_ENLARGED_SIBLINGS, MAX_SIBLING_DEPTH, MAX_SIBLING_CANDIDATES_EXPLORED, RELATIVE_IMPORT_PATTERN, SIBLING_FILE_EXTENSIONS, TS_ESM_EXTENSION_REWRITES, IDENTIFIER_PATTERN, _cliCacheVersionCache;
 var init_db = __esm({
   "packages/experience-design-system-cli-legacy/src/session/db.ts"() {
@@ -9891,37 +9919,6 @@ var init_GateStep = __esm({
   }
 });
 
-// packages/experience-design-system-cli-legacy/src/import/tui/handoff.ts
-import { HANDOFF_ENV, parseHandoff } from "@contentful/experience-design-system-types/handoff";
-function stateFromHandoff(handoff) {
-  const { extraction } = handoff;
-  return {
-    credentialsSkipped: handoff.credentialsSkipped,
-    ...extraction ? {
-      tokensPath: extraction.tokensPath,
-      tokenSessionId: extraction.tokenSessionId,
-      tokenCount: extraction.tokenCount,
-      tokenGenerationStatus: "complete",
-      outDir: extraction.outDir,
-      extractSessionId: extraction.sessionId,
-      compositionPhase: extraction.compositionPhase,
-      selectionAgentStatus: "complete",
-      existingEntitiesStatus: extraction.existingEntitiesStatus,
-      existingEntitiesPath: extraction.existingEntitiesPath
-    } : {}
-  };
-}
-function readHandoff(env = process.env) {
-  const parsed = parseHandoff(env[HANDOFF_ENV]);
-  if (!parsed.ok) return parsed;
-  return { ok: true, handoff: parsed.handoff, state: stateFromHandoff(parsed.handoff) };
-}
-var init_handoff = __esm({
-  "packages/experience-design-system-cli-legacy/src/import/tui/handoff.ts"() {
-    "use strict";
-  }
-});
-
 // packages/experience-design-system-cli-legacy/src/tui/use-terminal-size.ts
 import { useStdout } from "ink";
 import { useEffect as useEffect4, useState as useState6 } from "react";
@@ -27244,6 +27241,80 @@ var init_runScopeGate = __esm({
   }
 });
 
+// packages/experience-design-system-cli-legacy/src/helpers/build-contentful-management-client.ts
+import { createClient as createClient2 } from "contentful-management";
+function buildContentfulManagementClient(opts) {
+  return createClient2(
+    {
+      accessToken: opts.cmaToken,
+      ...opts.host ? { host: toConfiguredHost(opts.host) } : {}
+    },
+    { type: "plain" }
+  );
+}
+var init_build_contentful_management_client = __esm({
+  "packages/experience-design-system-cli-legacy/src/helpers/build-contentful-management-client.ts"() {
+    "use strict";
+    init_host_utils();
+  }
+});
+
+// packages/experience-design-system-cli-legacy/src/helpers/fetch-existing-contentful-entities.ts
+import { fetchAll } from "contentful-management";
+async function fetchExistingContentfulEntitiesFromContentful(client2, params) {
+  const componentScope = {
+    spaceId: params.spaceId,
+    environmentId: params.environmentId,
+    query: { cursor: true, limit: 1e3 }
+  };
+  const tokenScope = {
+    spaceId: params.spaceId,
+    environmentId: params.environmentId,
+    query: { cursor: true, limit: 1e3 }
+  };
+  const components = await fetchAll(client2.component.getMany, componentScope);
+  const tokens = await fetchAll(client2.designToken.getMany, tokenScope);
+  return { components, tokens };
+}
+var init_fetch_existing_contentful_entities = __esm({
+  "packages/experience-design-system-cli-legacy/src/helpers/fetch-existing-contentful-entities.ts"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-cli-legacy/src/helpers/fetch-and-persist-existing-contentful-entities.ts
+import { writeFile as writeFile4 } from "node:fs/promises";
+import { join as join19 } from "node:path";
+async function fetchAndPersistExistingContentfulEntities(params) {
+  const t0 = Date.now();
+  try {
+    const client2 = buildContentfulManagementClient({
+      cmaToken: params.cmaToken,
+      ...params.host ? { host: params.host } : {}
+    });
+    const entities = await fetchExistingContentfulEntitiesFromContentful(client2, {
+      spaceId: params.spaceId,
+      environmentId: params.environmentId
+    });
+    const path = join19(params.outDir, ".existing-entities.json");
+    await writeFile4(path, JSON.stringify(entities, null, 2), "utf8");
+    return { ok: true, path, durationMs: Date.now() - t0, entities };
+  } catch (error) {
+    return {
+      ok: false,
+      durationMs: Date.now() - t0,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var init_fetch_and_persist_existing_contentful_entities = __esm({
+  "packages/experience-design-system-cli-legacy/src/helpers/fetch-and-persist-existing-contentful-entities.ts"() {
+    "use strict";
+    init_build_contentful_management_client();
+    init_fetch_existing_contentful_entities();
+  }
+});
+
 // packages/experience-design-system-cli-legacy/src/import/tui/wizard-state-transitions.ts
 function shouldGenerateAfterScopeGate(opts) {
   return opts.acceptedCount > 0;
@@ -27279,11 +27350,121 @@ var init_wizard_state_transitions = __esm({
   }
 });
 
+// packages/experience-design-system-cli-legacy/src/import/tui/run-selection-agent.ts
+async function runSelectionAgent(options) {
+  const db = openPipelineDb();
+  let components;
+  const cachedDecisions = /* @__PURE__ */ new Map();
+  const cliVersion2 = await getCliCacheVersion();
+  const promptHash = await hashPromptForSkill(
+    "select",
+    options.agent,
+    options.model,
+    options.promptPath,
+    [],
+    options.promptText
+  );
+  try {
+    components = loadRawComponents(db, options.sessionId);
+    if (!options.noCache) {
+      for (const component of components) {
+        const componentHash = hashComponentShape(component);
+        const cached = lookupSelectCache(db, componentHash, promptHash, cliVersion2);
+        if (cached) {
+          cachedDecisions.set(component.name, {
+            decision: cached.decision,
+            reason: cached.reason
+          });
+        }
+      }
+    }
+  } finally {
+    db.close();
+  }
+  if (components.length === 0) return;
+  const componentsToRun = components.filter((component) => !cachedDecisions.has(component.name));
+  let calls = [];
+  if (componentsToRun.length > 0) {
+    const invoker2 = createLocalCliAgentInvoker({
+      onDebugEvent: (name, payload) => getDebugLogger().event("agent", name, payload)
+    });
+    const prompt = await buildPrompt({
+      skill: "select",
+      mode: "autonomous",
+      rawComponentsInline: JSON.stringify(componentsToRun, null, 2),
+      outDir: process.cwd(),
+      ...options.promptText !== void 0 ? { skillContentOverride: options.promptText } : {},
+      ...options.promptText === void 0 && options.promptPath ? { skillPathOverride: options.promptPath } : {}
+    });
+    const { result } = await invokeAgentWithOutput(
+      invoker2,
+      { agent: options.agent, model: options.model, prompt, timeoutMs: DEFAULT_TIMEOUT_MS4 },
+      false
+    );
+    if (result.timedOut) throw new Error("selection agent timed out");
+    if (result.exitCode !== 0) throw new Error(`selection agent exited with code ${result.exitCode}`);
+    const parsed = parseSelectToolCallLines(result.stdout);
+    for (const warning of parsed.warnings) process.stderr.write(`Warning: selection agent: ${warning}
+`);
+    calls = parsed.calls;
+  }
+  const byName = new Map(calls.map((call) => [call.name, call]));
+  const writeDb = openPipelineDb();
+  try {
+    writeDb.exec("BEGIN");
+    const update = writeDb.prepare(
+      `UPDATE raw_components SET status = ?, reject_reason = ? WHERE session_id = ? AND component_id = ?`
+    );
+    for (const component of components) {
+      const cached = cachedDecisions.get(component.name);
+      const call = byName.get(component.name);
+      if (!cached && !call) continue;
+      const rejected = cached ? cached.decision === "rejected" : call.tool === "reject_component";
+      const reason = cached ? cached.reason : call.reason ?? null;
+      update.run(
+        rejected ? "rejected" : "accepted",
+        rejected ? reason : null,
+        options.sessionId,
+        component.component_id
+      );
+      if (!cached) {
+        storeSelectCache(
+          writeDb,
+          hashComponentShape(component),
+          promptHash,
+          cliVersion2,
+          rejected ? "rejected" : "accepted",
+          rejected ? reason : null
+        );
+      }
+    }
+    writeDb.exec("COMMIT");
+  } catch (error) {
+    writeDb.exec("ROLLBACK");
+    throw error;
+  } finally {
+    writeDb.close();
+  }
+}
+var DEFAULT_TIMEOUT_MS4;
+var init_run_selection_agent = __esm({
+  "packages/experience-design-system-cli-legacy/src/import/tui/run-selection-agent.ts"() {
+    "use strict";
+    init_src();
+    init_debug_logger();
+    init_agent_output();
+    init_db();
+    init_cache_keys();
+    DEFAULT_TIMEOUT_MS4 = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 5 * 60 * 1e3);
+  }
+});
+
 // packages/experience-design-system-cli-legacy/src/import/tui/WizardApp.tsx
 var WizardApp_exports = {};
 __export(WizardApp_exports, {
   WizardApp: () => WizardApp,
   buildGenerateComponentsArgs: () => buildGenerateComponentsArgs,
+  buildGenerateTokensArgs: () => buildGenerateTokensArgs,
   buildMapTokensArgs: () => buildMapTokensArgs,
   buildSavedCDF: () => buildSavedCDF,
   formatAcceptanceSummary: () => formatAcceptanceSummary,
@@ -27292,11 +27473,11 @@ __export(WizardApp_exports, {
 });
 import { useEffect as useEffect14, useRef as useRef9, useState as useState19 } from "react";
 import { Box as Box38, Text as Text40 } from "ink";
-import { join as join19, resolve as resolve18 } from "node:path";
+import { join as join20, resolve as resolve18 } from "node:path";
 import { appendFileSync as appendFileSync2, writeFileSync } from "node:fs";
-import { writeFile as writeFile4 } from "node:fs/promises";
+import { writeFile as writeFile5 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile2, spawn as spawn5 } from "node:child_process";
 import { mkdir as mkdir4 } from "node:fs/promises";
 import { buildCDF as buildCDF3, validateCDF as validateCDF3, validateSlotReferences as validateSlotReferences2 } from "@contentful/experience-design-system-types";
 import { jsx as jsx47, jsxs as jsxs39 } from "react/jsx-runtime";
@@ -27315,6 +27496,14 @@ function buildGenerateComponentsArgs(opts) {
   }
   return args;
 }
+function buildGenerateTokensArgs(opts) {
+  const args = [findCliPath(), "__generate", "tokens", "--agent", opts.agent, "--raw-tokens", opts.rawTokensPath];
+  if (opts.model) args.push("--model", opts.model);
+  if (opts.bedrock) args.push("--bedrock");
+  if (opts.noCache) args.push("--no-cache");
+  for (const prompt of opts.promptOverrides ?? []) args.push("--prompt", prompt);
+  return args;
+}
 function buildMapTokensArgs(opts) {
   const args = ["map", "tokens", "--session", opts.sessionId, "--agent", opts.agent];
   if (opts.model) args.push("--model", opts.model);
@@ -27348,6 +27537,24 @@ function runCli(args) {
     });
   });
 }
+function runSpawnedCli(args, onStderr, onStdout) {
+  return new Promise((res) => {
+    const child = spawn5("node", args);
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      const chunk = String(d);
+      stdout += chunk;
+      onStdout?.(chunk);
+    });
+    child.stderr.on("data", (d) => {
+      const chunk = String(d);
+      stderr += chunk;
+      onStderr?.(chunk);
+    });
+    child.on("exit", (code) => res({ exitCode: code ?? 0, stdout, stderr }));
+  });
+}
 function buildGenerateProcessArgs(opts) {
   return [findCliPath(), ...buildGenerateComponentsArgs(opts)];
 }
@@ -27417,16 +27624,19 @@ function WizardApp({
   const allowEmptyDeleteAllRef = useRef9(false);
   const generationCachePreflightRef = useRef9(null);
   const selectionToReviewStartedAtRef = useRef9(null);
+  const tokenGenerationPromiseRef = useRef9(null);
+  const extractPromiseRef = useRef9(null);
+  const extractStartedRef = useRef9(false);
   const credentialsReadyRef = useRef9(false);
   const agentAuthVerifiedRef = useRef9(false);
   const scopeGateCompletedRef = useRef9(false);
   const scopeComponentsRef = useRef9(null);
+  const existingEntitiesPromiseRef = useRef9(null);
   const generatePromiseRef = useRef9(null);
   const rawTokensEntryReady = !!initialRawTokensPath;
   const effectiveNoCache = resolveNoCacheForGenerate({ cliNoCache: noCache });
-  const [startedFrom] = useState19(() => readHandoff());
-  const initialStepResolved = startedFrom.ok ? "credentials" : "error";
-  const initialOutDir = initialProjectPath ? join19(resolve18(initialProjectPath), ".contentful") : "";
+  const initialStepResolved = "credentials";
+  const initialOutDir = initialProjectPath ? join20(resolve18(initialProjectPath), ".contentful") : "";
   const [state, setState] = useState19({
     step: initialStepResolved,
     agent: initialAgent ?? "claude",
@@ -27436,6 +27646,7 @@ function WizardApp({
     outDir: initialOutDir,
     rawTokensPath: rawTokensEntryReady ? initialRawTokensPath : "",
     tokensPath: "",
+    skipComponents: false,
     tokenSessionId: null,
     tokenGenerationStatus: "idle",
     mapTokensStatus: "idle",
@@ -27448,6 +27659,7 @@ function WizardApp({
     generatedAcceptedCount: 0,
     generateProgress: null,
     selectionAgentStatus: "idle",
+    extractProgress: null,
     compositionPhase: null,
     componentsPath: "",
     spaceId: initialSpaceId,
@@ -27472,12 +27684,12 @@ function WizardApp({
     credentialsValidating: false,
     credentialsBackgroundValidating: false,
     mapTokensEligible: null,
+    credentialsSkipped: false,
     existingEntitiesPath: null,
     existingEntitiesStatus: "idle",
     lastRunId: null,
     finalizeErrorBanner: null,
-    finalReviewPassed: false,
-    ...startedFrom.ok ? startedFrom.state : { credentialsSkipped: false, errorStep: "start import", errorMessage: startedFrom.error }
+    finalReviewPassed: false
   });
   useEffect14(() => {
     sessionRef.current = {
@@ -27597,6 +27809,58 @@ If you are using AWS Bedrock, run:
     if (!deferStep) update({ step: nextStep });
     return true;
   };
+  const runGenerateTokens = async (rawTokensPath, outDir, forceRegenerate = false) => {
+    update({ tokenGenerationStatus: "running" });
+    const tokenArgs = buildGenerateTokensArgs({
+      rawTokensPath,
+      agent: state.agent,
+      ...state.agentModel ? { model: state.agentModel } : {},
+      ...state.bedrock ? { bedrock: true } : {},
+      noCache: effectiveNoCache || forceRegenerate,
+      promptOverrides
+    });
+    const result = await runSpawnedCli(tokenArgs);
+    if (result.exitCode !== 0) {
+      update({
+        step: "error",
+        tokenGenerationStatus: "failed",
+        errorStep: "generate tokens",
+        errorMessage: result.stderr.trim() || "Unknown error"
+      });
+      return false;
+    }
+    const sessionMatch = /^session=(.+)$/m.exec(result.stdout);
+    const tokenSessionId = sessionMatch ? sessionMatch[1].trim() : null;
+    const tokensPath = join20(outDir, "tokens.json");
+    const printArgs = ["print", "tokens", "--out", tokensPath];
+    if (tokenSessionId) printArgs.push("--session", tokenSessionId);
+    const r = await runCli(printArgs);
+    if (r.exitCode !== 0) {
+      update({
+        step: "error",
+        tokenGenerationStatus: "failed",
+        errorStep: "print tokens",
+        errorMessage: r.stderr.trim() || "Unknown error"
+      });
+      return false;
+    }
+    const tokenCount = parsePrintTokensCount(r.stdout);
+    if (!state.projectPath) {
+      update({
+        tokensPath,
+        tokenSessionId,
+        tokenCount,
+        tokenGenerationStatus: "complete",
+        skipComponents: true,
+        acceptedCount: 0,
+        outDir: state.outDir || join20(process.cwd(), ".contentful")
+      });
+      update({ step: "credentials" });
+      return true;
+    }
+    update({ tokensPath, tokenSessionId, tokenCount, tokenGenerationStatus: "complete" });
+    return true;
+  };
   const runMapTokens2 = async (sessionId2, silent = false) => {
     const timer = startWizardTimer("token-mapping", {
       sessionId: sessionId2,
@@ -27680,6 +27944,236 @@ If you are using AWS Bedrock, run:
     });
     return true;
   };
+  const startExistingEntitiesFetch = (projectPath, outDir) => {
+    if (state.credentialsSkipped || !state.spaceId || !state.environmentId || !state.cmaToken || !projectPath) {
+      return null;
+    }
+    const startedAt = Date.now();
+    getDebugLogger().event("wizard", "existing-entities.fetch.start", {
+      spaceId: state.spaceId,
+      environmentId: state.environmentId,
+      host: state.host,
+      outDir
+    });
+    update({ existingEntitiesStatus: "running" });
+    const promise = (async () => {
+      try {
+        await mkdir4(outDir, { recursive: true });
+        const result = await fetchAndPersistExistingContentfulEntities({
+          spaceId: state.spaceId,
+          environmentId: state.environmentId,
+          cmaToken: state.cmaToken,
+          ...state.host ? { host: state.host } : {},
+          outDir
+        });
+        if (result.ok) {
+          getDebugLogger().event("wizard", "existing-entities.fetch.ok", {
+            durationMs: result.durationMs,
+            components: result.entities.components.length,
+            tokens: result.entities.tokens.length
+          });
+          update({ existingEntitiesPath: result.path, existingEntitiesStatus: "complete" });
+          return true;
+        }
+        getDebugLogger().event("wizard", "existing-entities.fetch.error", {
+          durationMs: result.durationMs,
+          error: result.error
+        });
+        update({ existingEntitiesStatus: "failed" });
+        return false;
+      } catch (error) {
+        getDebugLogger().event("wizard", "existing-entities.fetch.error", {
+          durationMs: Date.now() - startedAt,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        update({ existingEntitiesStatus: "failed" });
+        return false;
+      }
+    })();
+    existingEntitiesPromiseRef.current = promise;
+    return promise;
+  };
+  const runExtract = async (projectPath, showProgress = true) => {
+    const outDir = join20(resolve18(projectPath), ".contentful");
+    const existingEntitiesExpected = !state.credentialsSkipped && Boolean(state.spaceId && state.environmentId && state.cmaToken && projectPath);
+    update({
+      ...showProgress ? { step: "extracting" } : {},
+      outDir,
+      extractProgress: null,
+      compositionPhase: "resolving",
+      // Put every extraction-stage task on the first frame. The selection
+      // agent cannot start until extraction emits its session, but it is
+      // already part of this stage and should not appear later as a new row.
+      selectionAgentStatus: state.agent ? "running" : "complete",
+      existingEntitiesStatus: existingEntitiesExpected ? "running" : "idle"
+    });
+    const existingEntitiesPromise = startExistingEntitiesFetch(projectPath, outDir);
+    const extractArgs = [findCliPath(), "__extract", "--project", projectPath];
+    if (effectiveNoCache) extractArgs.push("--composition-refresh", "--no-cache");
+    for (const p of promptOverrides ?? []) extractArgs.push("--prompt", p);
+    if (state.agent) extractArgs.push("--agent", state.agent);
+    if (state.bedrock) extractArgs.push("--bedrock");
+    let selectionPromptText;
+    let selectionPromptPath;
+    try {
+      const { overrides, errors } = parsePromptOverrides(promptOverrides ?? []);
+      if (errors.length > 0) throw new Error(errors.join("; "));
+      const selectOverride = overrides.get("select");
+      if (selectOverride?.kind === "text") selectionPromptText = selectOverride.value;
+      if (selectOverride?.kind === "path") {
+        selectionPromptPath = resolve18(selectOverride.value);
+        await resolvePromptOverride(selectOverride);
+      }
+    } catch (error) {
+      update({
+        step: "error",
+        errorStep: "selection agent",
+        errorMessage: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    let selectionPromise = null;
+    let selectionError;
+    let selectionStarted = false;
+    const startSelection = (sessionId2) => {
+      if (selectionStarted || !state.agent) return;
+      selectionStarted = true;
+      selectionPromise = (async () => {
+        if (existingEntitiesPromise) await existingEntitiesPromise;
+        await runSelectionAgent({
+          sessionId: sessionId2,
+          agent: state.agent,
+          ...state.agentModel ? { model: state.agentModel } : {},
+          ...selectionPromptText !== void 0 ? { promptText: selectionPromptText } : {},
+          ...selectionPromptPath ? { promptPath: selectionPromptPath } : {},
+          noCache: effectiveNoCache
+        });
+      })().catch((error) => {
+        selectionError = error;
+      }).finally(() => update({ selectionAgentStatus: "complete" }));
+    };
+    let stderrBuffer = "";
+    let stdoutBuffer = "";
+    const r = await runSpawnedCli(
+      extractArgs,
+      (chunk) => {
+        stderrBuffer += chunk;
+        const lines = stderrBuffer.split("\n");
+        stderrBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const scanMatch = /^progress=scan:(\d+)$/.exec(line.trim());
+          if (scanMatch) {
+            const scanned = Number(scanMatch[1]);
+            setState((prev) => ({
+              ...prev,
+              extractProgress: {
+                scanned,
+                filesProcessed: prev.extractProgress?.filesProcessed ?? 0,
+                totalFiles: prev.extractProgress?.totalFiles ?? 0,
+                componentsFound: prev.extractProgress?.componentsFound ?? 0
+              }
+            }));
+            continue;
+          }
+          const scanDoneMatch = /^progress=scan-done:(\d+)$/.exec(line.trim());
+          if (scanDoneMatch) {
+            const scanned = Number(scanDoneMatch[1]);
+            setState((prev) => ({
+              ...prev,
+              extractProgress: {
+                scanned,
+                filesProcessed: prev.extractProgress?.filesProcessed ?? 0,
+                totalFiles: scanned,
+                componentsFound: prev.extractProgress?.componentsFound ?? 0
+              }
+            }));
+            continue;
+          }
+          const extractMatch = /^progress=extract:(\d+)\/(\d+):(\d+)$/.exec(line.trim());
+          if (extractMatch) {
+            const filesProcessed = Number(extractMatch[1]);
+            const totalFiles = Number(extractMatch[2]);
+            const componentsFound = Number(extractMatch[3]);
+            setState((prev) => ({
+              ...prev,
+              extractProgress: {
+                scanned: prev.extractProgress?.scanned ?? 0,
+                filesProcessed,
+                totalFiles,
+                componentsFound
+              }
+            }));
+            continue;
+          }
+          const compositionMatch = /^progress=composition:(.+)$/.exec(line.trim());
+          if (compositionMatch) {
+            setState((prev) => ({ ...prev, compositionPhase: compositionMatch[1].trim() }));
+          }
+        }
+      },
+      (chunk) => {
+        stdoutBuffer += chunk;
+        const lines = stdoutBuffer.split("\n");
+        stdoutBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const sessionMatch2 = /^session=(.+)$/.exec(line.trim());
+          if (sessionMatch2) startSelection(sessionMatch2[1].trim());
+        }
+      }
+    );
+    const sessionMatch = /^session=(.+)$/m.exec(r.stdout);
+    if (!selectionStarted && sessionMatch) startSelection(sessionMatch[1].trim());
+    if (selectionPromise) await selectionPromise;
+    if (!selectionStarted && existingEntitiesPromise) await existingEntitiesPromise;
+    if (r.exitCode !== 0) {
+      update({
+        step: "error",
+        errorStep: "analyze extract",
+        errorMessage: r.stderr.trim() || "Unknown error"
+      });
+      return;
+    }
+    const extractSessionId = sessionMatch ? sessionMatch[1].trim() : null;
+    const countMatch = /Extracted (\d+) components?/.exec(r.stderr);
+    const extractedCount = countMatch ? Number(countMatch[1]) : 0;
+    if (extractedCount === 0) {
+      update({
+        step: "error",
+        errorStep: "analyze extract",
+        errorMessage: `No components found in ${projectPath}.
+
+Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .vue, etc.).`
+      });
+      return;
+    }
+    if (selectionError) {
+      update({
+        step: "error",
+        errorStep: "selection agent",
+        errorMessage: selectionError instanceof Error ? selectionError.message : String(selectionError)
+      });
+      return;
+    }
+    if (state.rawTokensPath && tokenGenerationPromiseRef.current) {
+      const tokenGenerationSucceeded = await tokenGenerationPromiseRef.current;
+      tokenGenerationPromiseRef.current = null;
+      if (!tokenGenerationSucceeded) return;
+    }
+    update({
+      extractSessionId,
+      selectionAgentStatus: "complete",
+      ...credentialsReadyRef.current ? { step: "scope-gate" } : {}
+    });
+  };
+  const startExtract = (projectPath, showProgress = true) => {
+    if (extractStartedRef.current) return;
+    extractStartedRef.current = true;
+    const promise = runExtract(projectPath, showProgress);
+    extractPromiseRef.current = promise;
+    void promise.finally(() => {
+      extractPromiseRef.current = null;
+    });
+  };
   const buildGenerateOptions = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => ({
     sessionId: extractSessionId,
     tokensPath,
@@ -27765,7 +28259,7 @@ If you are using AWS Bedrock, run:
     }
   };
   useEffect14(() => {
-    if (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) {
+    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;
@@ -27920,16 +28414,14 @@ If you are using AWS Bedrock, run:
   };
   const advanceAfterCredentialsValidated = async () => {
     credentialsReadyRef.current = true;
-    if (!sessionRef.current.extractSessionId) {
-      update({
-        step: "error",
-        errorStep: "start import",
-        errorMessage: "Internal error: the CLI did not hand over an extract session."
-      });
+    if (!sessionRef.current.extractSessionId && state.projectPath) {
+      if (extractPromiseRef.current) update({ step: "extracting" });
+      else startExtract(state.projectPath);
       return;
     }
-    if (!scopeGateCompletedRef.current) {
-      update({ step: "scope-gate" });
+    if (!scopeGateCompletedRef.current && sessionRef.current.extractSessionId) {
+      if (extractPromiseRef.current) update({ step: "extracting" });
+      else update({ step: "scope-gate" });
       return;
     }
     if (shouldSkipFinalReviewAfterCredentials({
@@ -28313,7 +28805,7 @@ If using a custom host configuration, make sure the space exists on that host.`
   };
   const runPrintFiles = async (extractSessionId, outDir, opts = {}) => {
     update({ step: "printing" });
-    const componentsPath = join19(outDir, "components.json");
+    const componentsPath = join20(outDir, "components.json");
     try {
       const db = openPipelineDb();
       let components = [];
@@ -28326,7 +28818,7 @@ If using a custom host configuration, make sure the space exists on that host.`
       }
       if (!opts.tokenSessionId && opts.tokensPath) tokens = await readTokensFromPath("tokens", opts.tokensPath);
       const cdf = buildSavedCDF(components, tokens, { deleteAll: opts.allowEmpty });
-      await writeFile4(componentsPath, `${JSON.stringify(cdf, null, 2)}
+      await writeFile5(componentsPath, `${JSON.stringify(cdf, null, 2)}
 `);
       process.stderr.write(
         `wrote ${componentsPath} (${components.length} component${components.length === 1 ? "" : "s"}, ${tokens.length} token${tokens.length === 1 ? "" : "s"})
@@ -28410,6 +28902,23 @@ If using a custom host configuration, make sure the space exists on that host.`
       void runPreview(extractSessionId, tokensPath, state.spaceId, state.environmentId, state.cmaToken, state.host);
     }
   };
+  const tokenStrategyApplied = useRef9(false);
+  useEffect14(() => {
+    if (!state.rawTokensPath || tokenStrategyApplied.current) return;
+    tokenStrategyApplied.current = true;
+    const strategy = process.env["EDS_IMPORT_TOKENS"];
+    if (strategy === "reuse") {
+      update({
+        tokensPath: join20(state.outDir, "tokens.json"),
+        tokenSessionId: null,
+        tokenGenerationStatus: "complete"
+      });
+      return;
+    }
+    tokenGenerationPromiseRef.current = runAgentAuthCheck("credentials").then(
+      (ok2) => ok2 ? runGenerateTokens(state.rawTokensPath, state.outDir, strategy === "regenerate") : false
+    );
+  }, [state.rawTokensPath]);
   const credentialsHandedOff = useRef9(false);
   useEffect14(() => {
     if (state.step !== "credentials" || credentialsHandedOff.current) return;
@@ -28420,6 +28929,7 @@ If using a custom host configuration, make sure the space exists on that host.`
   const noQuitSteps = [
     "checking-claude-auth",
     "validating-credentials",
+    "extracting",
     "generating",
     "mapping-tokens",
     "printing",
@@ -28429,7 +28939,8 @@ If using a custom host configuration, make sure the space exists on that host.`
   const hints = noQuitSteps.includes(state.step) ? [] : [{ key: "q", label: "quit" }];
   const hasTokens = !!state.tokensPath;
   const hasTokenStage = hasTokens || !!state.rawTokensPath;
-  const totalSteps = 3 + (hasTokenStage ? 1 : 0) + 2 + (state.mapTokensEligible === true ? 1 : 0);
+  const hasComponents = !state.skipComponents;
+  const totalSteps = 3 + (hasTokenStage ? 1 : 0) + (hasComponents ? 2 : 0) + (state.mapTokensEligible === true ? 1 : 0);
   const stepContent = (() => {
     switch (state.step) {
       case "checking-claude-auth":
@@ -28442,6 +28953,44 @@ If using a custom host configuration, make sure the space exists on that host.`
             description: `Verifying ${state.agent} is installed and authenticated...`
           }
         );
+      case "extracting": {
+        const ep = state.extractProgress;
+        const compositionComplete = state.compositionPhase === "done" || state.compositionPhase === "cache-hit";
+        const tokenGenerationComplete = !state.rawTokensPath || state.tokenGenerationStatus === "complete";
+        const extractionTasksComplete = ep !== null && ep.totalFiles > 0 && compositionComplete && state.selectionAgentStatus === "complete" && tokenGenerationComplete && state.existingEntitiesStatus !== "running";
+        if (extractionTasksComplete) return null;
+        let extractDetail;
+        let extractComplete = false;
+        if (ep && ep.totalFiles > 0) {
+          extractDetail = `Scanned ${ep.scanned} file${ep.scanned === 1 ? "" : "s"}`;
+          extractComplete = true;
+        } else if (ep) {
+          extractDetail = `Scanning ${ep.scanned} file${ep.scanned === 1 ? "" : "s"}`;
+        } else {
+          extractDetail = "Scanning files...";
+        }
+        const selectionDetail = state.selectionAgentStatus === "complete" ? "Selection agent complete" : `Filtering component selection via ${state.agent}...`;
+        const compositionDetail = state.compositionPhase === "cache-hit" ? "Composition mapping (cached)" : compositionComplete ? "Composition mapping complete" : state.compositionPhase?.startsWith("agent:") ? `Mapping composition via ${state.compositionPhase.slice("agent:".length)}...` : `Mapping composition via ${state.agent}...`;
+        return /* @__PURE__ */ jsx47(
+          RunningStep,
+          {
+            stepNumber: hasTokenStage ? 2 : 1,
+            totalSteps,
+            title: "Extracting context",
+            description: "Extracting context from your source files.",
+            detail: extractDetail,
+            detailComplete: extractComplete,
+            secondaryDetail: compositionDetail,
+            secondaryComplete: compositionComplete,
+            tertiaryDetail: selectionDetail,
+            tertiaryComplete: state.selectionAgentStatus === "complete",
+            quaternaryDetail: state.existingEntitiesStatus === "running" ? "Fetching existing components and tokens..." : state.existingEntitiesStatus === "complete" ? "Existing components and tokens ready" : state.existingEntitiesStatus === "failed" ? "Existing entities unavailable; continuing without them" : void 0,
+            quaternaryComplete: state.existingEntitiesStatus === "complete" || state.existingEntitiesStatus === "failed",
+            quinaryDetail: state.rawTokensPath ? state.tokenGenerationStatus === "running" ? `Generating token definitions via ${state.agent}...` : state.tokenGenerationStatus === "complete" ? "Token definitions ready" : state.tokenGenerationStatus === "failed" ? "Token definition generation failed" : `Generating token definitions via ${state.agent}...` : void 0,
+            quinaryComplete: state.tokenGenerationStatus === "complete"
+          }
+        );
+      }
       case "scope-gate": {
         if (!state.extractSessionId) {
           return /* @__PURE__ */ jsx47(Box38, { paddingX: 2, paddingY: 1, children: /* @__PURE__ */ jsx47(Text40, { color: PALETTE.error, children: "Error: extract session ID missing \u2014 please re-run." }) });
@@ -28727,7 +29276,9 @@ ${displayAgent} is mapping your selected components to Contentful's Component De
           GateStep,
           {
             successMessage: "Files saved",
-            summary: [state.componentsPath ? `components.json \u2192 ${state.componentsPath}` : null].filter(Boolean).join("\n"),
+            summary: [
+              (hasComponents || hasTokens) && state.componentsPath ? `components.json \u2192 ${state.componentsPath}` : null
+            ].filter(Boolean).join("\n"),
             context: teaser ? `Your files are saved to disk. ${teaser}` : "Your files are saved to disk. Run `experiences import` again when you're ready to push to Contentful.",
             continueLabel: "Exit",
             showSkip: false,
@@ -28811,7 +29362,6 @@ var init_WizardApp = __esm({
     init_CustomPromptBanner();
     init_RunningStep();
     init_GateStep();
-    init_handoff();
     init_WizardPreviewStep();
     init_DoneStep();
     init_ErrorStep();
@@ -28834,12 +29384,15 @@ var init_WizardApp = __esm({
     init_runScopeGate();
     init_src();
     init_host_utils();
+    init_fetch_and_persist_existing_contentful_entities();
     init_wizard_state_transitions();
     init_cli_path();
+    init_prompt_overrides();
+    init_run_selection_agent();
     init_use_terminal_size();
     init_render_with_goodbye();
     SAVE_CONFIRMATION_DELAY_MS = 1e3;
-    WIZARD_LOG = join19(tmpdir(), "experiences-import-wizard.log");
+    WIZARD_LOG = join20(tmpdir(), "experiences-import-wizard.log");
   }
 });
 
@@ -28970,7 +29523,7 @@ var init_agent_definitions = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/setup/lib/shell.ts
-import { execFile as execFile3, spawn as spawn5 } from "node:child_process";
+import { execFile as execFile3, spawn as spawn6 } from "node:child_process";
 import { access as access7 } from "node:fs/promises";
 import { promisify as promisify2 } from "node:util";
 async function binaryExists(name) {
@@ -28986,7 +29539,7 @@ async function pathExists3(path) {
 }
 function runSpawn(cmd, args, opts = {}) {
   return new Promise((resolve22) => {
-    const child = spawn5(cmd, args, {
+    const child = spawn6(cmd, args, {
       cwd: opts.cwd,
       env: opts.env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -29019,7 +29572,7 @@ var init_shell = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/setup/lib/checks.ts
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function checkNodeVersion(nodeVersion = process.versions.node) {
   const major = Number.parseInt(nodeVersion.split(".")[0], 10);
   return {
@@ -29033,7 +29586,7 @@ async function detectNodeVersionManagers(homeDir, deps = {
   binaryExists,
   pathExists: pathExists3
 }) {
-  const nvmScript = join20(homeDir, ".nvm", "nvm.sh");
+  const nvmScript = join21(homeDir, ".nvm", "nvm.sh");
   return {
     nvm: await deps.binaryExists("nvm") || await deps.pathExists(nvmScript),
     fnm: await deps.binaryExists("fnm"),
@@ -29112,7 +29665,7 @@ var init_report = __esm({
 
 // packages/experience-design-system-cli-legacy/src/doctor/checks.ts
 import { homedir as homedir2 } from "node:os";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 async function reportNode() {
   section("Checking Node.js version");
   const check = checkNodeVersion();
@@ -29163,12 +29716,12 @@ async function reportPnpm(pkgRoot) {
 }
 async function reportDependencies(pkgRoot) {
   section("Checking dependencies (pnpm install)");
-  if (!await pathExists3(join21(pkgRoot, "node_modules"))) {
+  if (!await pathExists3(join22(pkgRoot, "node_modules"))) {
     info("node_modules not found \u2014 running pnpm install...");
   } else {
     info("Running pnpm install to ensure dependencies are up to date...");
   }
-  const check = await installDependencies(join21(pkgRoot, "..", ".."));
+  const check = await installDependencies(join22(pkgRoot, "..", ".."));
   if (!check.passed) {
     fail("pnpm install failed");
     info("");
@@ -29185,7 +29738,7 @@ async function reportDependencies(pkgRoot) {
 async function reportBuild(pkgRoot) {
   section("Building CLI");
   info("Running pnpm build...");
-  const check = await buildCli(join21(pkgRoot, "..", ".."));
+  const check = await buildCli(join22(pkgRoot, "..", ".."));
   if (!check.passed) {
     fail("Build failed");
     info("");
@@ -30404,9 +30957,9 @@ var init_SetupScreen = __esm({
 
 // packages/experience-design-system-cli-legacy/src/setup/command.ts
 import { readFileSync as readFileSync9 } from "node:fs";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 function getCliVersion() {
-  const pkg4 = JSON.parse(readFileSync9(join22(findPkgRoot(), "package.json"), "utf8"));
+  const pkg4 = JSON.parse(readFileSync9(join23(findPkgRoot(), "package.json"), "utf8"));
   return pkg4.version;
 }
 async function runSetup(opts) {
@@ -30418,7 +30971,7 @@ async function runSetup(opts) {
   const { renderWithGoodbye: renderWithGoodbye2 } = await Promise.resolve().then(() => (init_render_with_goodbye(), render_with_goodbye_exports));
   const { createElement: createElement6 } = await import("react");
   const { SetupScreen: SetupScreen2 } = await Promise.resolve().then(() => (init_SetupScreen(), SetupScreen_exports));
-  const repoRoot = join22(findPkgRoot(), "..", "..");
+  const repoRoot = join23(findPkgRoot(), "..", "..");
   const completion = { outcome: null };
   let unmountInk = null;
   const { waitUntilExit, unmount } = renderWithGoodbye2(
@@ -30620,14 +31173,14 @@ var init_apply_mapping = __esm({
 
 // packages/experience-design-system-cli-legacy/src/analyze/composition/prompt-loader.ts
 import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
-import { dirname as dirname18, join as join23, resolve as resolve19 } from "node:path";
+import { dirname as dirname18, join as join24, resolve as resolve19 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolvePromptPath(fileName) {
   const thisDir = dirname18(fileURLToPath3(import.meta.url));
   let dir = thisDir;
   for (; ; ) {
-    const candidate = join23(dir, "prompts");
-    if (existsSync10(candidate)) return join23(candidate, fileName);
+    const candidate = join24(dir, "prompts");
+    if (existsSync10(candidate)) return join24(candidate, fileName);
     const parent = resolve19(dir, "..");
     if (parent === dir) {
       throw new Error(
@@ -30895,7 +31448,7 @@ var init_manifest_doc_evidence = __esm({
 
 // packages/experience-design-system-cli-legacy/src/analyze/extract-command.ts
 import { mkdir as mkdir5, readdir as readdir3, readFile as readFile18, stat as stat5 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join24, relative as relative2, resolve as resolve20 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join25, relative as relative2, resolve as resolve20 } from "node:path";
 function resolveExtractNoCache(opts) {
   return opts.noCache === true || opts.cache === false;
 }
@@ -30928,7 +31481,7 @@ async function collectSourceFiles(directory, onProgress) {
     const entries = await readdir3(currentDirectory, { withFileTypes: true });
     const subdirs = [];
     for (const entry of entries) {
-      const fullPath = join24(currentDirectory, entry.name);
+      const fullPath = join25(currentDirectory, entry.name);
       if (entry.isDirectory()) {
         if (!IGNORED_DIRECTORY_NAMES.has(entry.name)) {
           subdirs.push(fullPath);
@@ -31012,7 +31565,7 @@ function registerInternalExtractCommand(program) {
       }
     }
     const projectRoot = resolve20(opts.project);
-    const outDir = join24(projectRoot, ".contentful");
+    const outDir = join25(projectRoot, ".contentful");
     let sourceDirectory;
     if (opts.dir !== void 0) {
       sourceDirectory = resolveFromProjectRoot(projectRoot, opts.dir);
@@ -31375,9 +31928,9 @@ __export(program_exports, {
   resolveBedrockFromAncestors: () => resolveBedrockFromAncestors,
   runBuild: () => runBuild
 });
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import { dirname as dirname20, join as join25, resolve as resolve21 } from "node:path";
+import { dirname as dirname20, join as join26, resolve as resolve21 } from "node:path";
 import { readFileSync as readFileSync11 } from "node:fs";
 import { Command } from "commander";
 async function runBuild(opts) {
@@ -31410,7 +31963,7 @@ function registerBuildCommand(program) {
     const pkgRoot = resolve21(dirname20(fileURLToPath4(import.meta.url)), "..", "..");
     process.stderr.write("\u2699  Building from source...\n");
     const { exitCode } = await runBuild({
-      spawnFn: () => spawn6("pnpm", ["build"], { cwd: pkgRoot, stdio: "inherit" }),
+      spawnFn: () => spawn7("pnpm", ["build"], { cwd: pkgRoot, stdio: "inherit" }),
       stderrWrite: (s) => process.stderr.write(s)
     });
     process.exit(exitCode);
@@ -31477,7 +32030,7 @@ var init_program = __esm({
     init_analytics();
     init_credentials_store();
     init_cli_path();
-    pkg3 = JSON.parse(readFileSync11(join25(findPkgRoot(), "package.json"), "utf8"));
+    pkg3 = JSON.parse(readFileSync11(join26(findPkgRoot(), "package.json"), "utf8"));
   }
 });