@algolia/wizard 0.6.0 → 0.7.0-rc.57.36

package/README.md

@@ -12,8 +12,22 @@ npx @algolia/wizard
 
 # run a specific workflow by id
 npx @algolia/wizard <workflow-id>
+
+# see all options
+npx @algolia/wizard --help
 ```
 
+### Options
+
+| Flag             | Effect                                                                                                                                                         |
+| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--seed <step-id>` | Start the workflow at the step with this id (e.g. `--seed ingestion`), with the earlier steps pre-filled with test data. Pass with no value to print the step ids. |
+| `--no-telemetry` | Send no telemetry or analytics for this run.                                                                                                                    |
+| `--reset-on-run` | Wipe this project's wizard state (run state, AI-changes consent, worktrees) before starting, so the run behaves like a first-ever run. Credentials are untouched. |
+| `-h`, `--help`   | Print usage.                                                                                                                                                   |
+
+`--seed` pre-fills the earlier steps with fabricated data so a single step can be exercised without running the whole workflow — useful for testing a step, not for a real implementation. It replaces any in-progress run for that workflow and pre-grants the AI-changes consent. See [Starting mid-workflow](CONTRIBUTING.md#starting-mid-workflow---seed).
+
 On first run, Wizard checks for an Algolia profile. If none exists it launches `algolia auth login` and writes a default profile.
 
 You'll also be asked once to consent to AI-authored changes to the repository.

package/dist/main.js

@@ -76,9 +76,9 @@ function refreshAuthToken() {
   inFlightRefresh ??= (async () => {
     try {
       const raw = await runAlgoliaCli(["auth", "get", "--with-access-token"]);
-      const user2 = toUserInfo(JSON.parse(raw));
-      useWizard.getState().setUser(user2);
-      return user2.token;
+      const user = toUserInfo(JSON.parse(raw));
+      useWizard.getState().setUser(user);
+      return user.token;
     } catch {
       return null;
     } finally {
@@ -210,9 +210,9 @@ var useWizard = create((set, get) => ({
       }
     });
   }),
-  startWorkflow: (workflow2, steps) => set({
+  startWorkflow: (workflow, steps) => set({
     phase: "running",
-    workflow: workflow2,
+    workflow,
     steps,
     currentStepIndex: 0,
     error: null
@@ -222,7 +222,7 @@ var useWizard = create((set, get) => ({
     get()._clearNoticeQueue();
     set({ phase: "running", currentStepIndex: index, output: "", notices: [] });
   },
-  setUser: (user2) => set({ user: user2 }),
+  setUser: (user) => set({ user }),
   appendToken: (text) => set((s) => ({ output: s.output + text })),
   clearOutput: () => set({ output: "" }),
   // Renders the first notice of a burst immediately, then holds later
@@ -1282,147 +1282,13 @@ function Logs() {
 
 // src/lib/events.ts
 import "zod";
-function track(event, payload) {
-  const token = getAuthToken();
-  if (!token) return;
-  const userId = useWizard.getState().user?.userId;
-  if (!userId) return;
-  void proxyFetch(`${PROXY_BASE_URL}/events`, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({ userId, event, properties: payload })
-  }).catch((err) => {
-    logger.warn({ err, event }, "failed to send analytics event");
-  });
-}
-
-// src/ui/App.tsx
-import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
-function App() {
-  const { phase, error, homeScreen, currentStepIndex, steps, inputReq } = useWizard();
-  const { exit } = useApp();
-  const { columns, rows } = useWindowSize7();
-  const [showLogs, setShowLogs] = useState6(false);
-  const finished = phase === "done" || phase === "error";
-  const currentStep = steps[currentStepIndex];
-  useInput6(
-    (_input, key) => {
-      if (key.return) {
-        exit();
-      }
-    },
-    { isActive: finished }
-  );
-  useInput6((_input, key) => {
-    if (phase === "idle" || phase === "preflight") return;
-    if (key.tab) {
-      setShowLogs(!showLogs);
-      track("AI Wizard Interaction", {
-        context: "global",
-        key: "tab",
-        currentStep: currentStep?.id
-      });
-    }
-  });
-  const escOwnedElsewhere = phase === "idle" || phase === "awaitingInput" && inputReq?.promptType === "enterToContinue";
-  useInput6((_input, key) => {
-    if (escOwnedElsewhere) return;
-    if (key.escape) {
-      track("AI Wizard Interaction", {
-        context: "global",
-        key: "esc",
-        // No step is active until `startWorkflow` — report the phase instead.
-        currentStep: currentStep?.id ?? phase
-      });
-      exit();
-    }
-  });
-  const mainWindowVisible = phase === "running" || phase === "awaitingInput" || phase === "error" || phase === "done";
-  const flexDirection = columns > 90 ? "row" : "column";
-  const showSidebar = flexDirection === "row";
-  return /* @__PURE__ */ jsxs12(
-    Box13,
-    {
-      backgroundColor: COLORS.bg.main,
-      flexDirection: "row",
-      width: columns,
-      minHeight: rows,
-      children: [
-        mainWindowVisible && /* @__PURE__ */ jsxs12(
-          Box13,
-          {
-            flexDirection,
-            width: "100%",
-            justifyContent: "space-between",
-            children: [
-              showLogs ? /* @__PURE__ */ jsx13(Logs, {}) : (
-                /* Fill the width beside the sidebar; row layout only (would grow vertically when stacked). */
-                /* @__PURE__ */ jsxs12(
-                  Box13,
-                  {
-                    flexDirection: "column",
-                    paddingX: 4,
-                    paddingY: 2,
-                    width: showSidebar ? 70 : "100%",
-                    flexGrow: showSidebar ? 1 : 0,
-                    children: [
-                      /* @__PURE__ */ jsx13(Notices, {}),
-                      /* @__PURE__ */ jsx13(PromptInput, {}),
-                      phase === "running" && showSidebar && /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(CurrentStep, {}) }),
-                      phase === "error" && error && /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsxs12(Text13, { color: COLORS.status.error, children: [
-                        "\u2716 ",
-                        error
-                      ] }) })
-                    ]
-                  }
-                )
-              ),
-              showSidebar ? /* @__PURE__ */ jsx13(Sidebar, {}) : /* @__PURE__ */ jsx13(Ribbon, {})
-            ]
-          }
-        ),
-        (phase === "idle" || phase === "preflight") && (homeScreen === "learnMore" ? /* @__PURE__ */ jsx13(LearnMore, {}) : /* @__PURE__ */ jsx13(Welcome, {}))
-      ]
-    }
-  );
-}
-
-// src/core/orchestrator.ts
-import "zod";
-
-// src/core/config.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join5 } from "node:path";
-var configFile = () => join5(stateDir(), "config.json");
-var DEFAULT_CONFIG = {
-  version: 1,
-  aiConsent: false,
-  workflowsRun: []
-};
-async function loadConfig() {
-  try {
-    const raw = await readFile2(configFile(), "utf8");
-    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
-  } catch {
-    return { ...DEFAULT_CONFIG };
-  }
-}
-async function saveConfig(config) {
-  await mkdir2(stateDir(), { recursive: true });
-  await writeFile2(configFile(), JSON.stringify(config, null, 2), "utf8");
-}
-async function recordWorkflowRun(workflowId, completedAt) {
-  const config = await loadConfig();
-  config.workflowsRun.push({ workflowId, completedAt });
-  await saveConfig(config);
-}
 
 // src/lib/telemetry.ts
+function isTelemetryOptedOut() {
+  return process.env.WIZARD_TELEMETRY === "false";
+}
 function isTelemetryEnabled() {
-  return Boolean(getAuthToken()) && !process.env.VITEST && process.env.WIZARD_TELEMETRY !== "false";
+  return Boolean(getAuthToken()) && !process.env.VITEST && !isTelemetryOptedOut();
 }
 function fireAndForget(promise) {
   void promise.catch(() => {
@@ -1582,6 +1448,146 @@ function trackWorkflowError(ctx) {
   );
 }
 
+// src/lib/events.ts
+function track(event, payload) {
+  if (isTelemetryOptedOut()) return;
+  const token = getAuthToken();
+  if (!token) return;
+  const userId = useWizard.getState().user?.userId;
+  if (!userId) return;
+  void proxyFetch(`${PROXY_BASE_URL}/events`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ userId, event, properties: payload })
+  }).catch((err) => {
+    logger.warn({ err, event }, "failed to send analytics event");
+  });
+}
+
+// src/ui/App.tsx
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+function App() {
+  const { phase, error, homeScreen, currentStepIndex, steps, inputReq } = useWizard();
+  const { exit } = useApp();
+  const { columns, rows } = useWindowSize7();
+  const [showLogs, setShowLogs] = useState6(false);
+  const finished = phase === "done" || phase === "error";
+  const currentStep = steps[currentStepIndex];
+  useInput6(
+    (_input, key) => {
+      if (key.return) {
+        exit();
+      }
+    },
+    { isActive: finished }
+  );
+  useInput6((_input, key) => {
+    if (phase === "idle" || phase === "preflight") return;
+    if (key.tab) {
+      setShowLogs(!showLogs);
+      track("AI Wizard Interaction", {
+        context: "global",
+        key: "tab",
+        currentStep: currentStep?.id
+      });
+    }
+  });
+  const escOwnedElsewhere = phase === "idle" || phase === "awaitingInput" && inputReq?.promptType === "enterToContinue";
+  useInput6((_input, key) => {
+    if (escOwnedElsewhere) return;
+    if (key.escape) {
+      track("AI Wizard Interaction", {
+        context: "global",
+        key: "esc",
+        // No step is active until `startWorkflow` — report the phase instead.
+        currentStep: currentStep?.id ?? phase
+      });
+      exit();
+    }
+  });
+  const mainWindowVisible = phase === "running" || phase === "awaitingInput" || phase === "error" || phase === "done";
+  const flexDirection = columns > 90 ? "row" : "column";
+  const showSidebar = flexDirection === "row";
+  return /* @__PURE__ */ jsxs12(
+    Box13,
+    {
+      backgroundColor: COLORS.bg.main,
+      flexDirection: "row",
+      width: columns,
+      minHeight: rows,
+      children: [
+        mainWindowVisible && /* @__PURE__ */ jsxs12(
+          Box13,
+          {
+            flexDirection,
+            width: "100%",
+            justifyContent: "space-between",
+            children: [
+              showLogs ? /* @__PURE__ */ jsx13(Logs, {}) : (
+                /* Fill the width beside the sidebar; row layout only (would grow vertically when stacked). */
+                /* @__PURE__ */ jsxs12(
+                  Box13,
+                  {
+                    flexDirection: "column",
+                    paddingX: 4,
+                    paddingY: 2,
+                    width: showSidebar ? 70 : "100%",
+                    flexGrow: showSidebar ? 1 : 0,
+                    children: [
+                      /* @__PURE__ */ jsx13(Notices, {}),
+                      /* @__PURE__ */ jsx13(PromptInput, {}),
+                      phase === "running" && showSidebar && /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(CurrentStep, {}) }),
+                      phase === "error" && error && /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsxs12(Text13, { color: COLORS.status.error, children: [
+                        "\u2716 ",
+                        error
+                      ] }) })
+                    ]
+                  }
+                )
+              ),
+              showSidebar ? /* @__PURE__ */ jsx13(Sidebar, {}) : /* @__PURE__ */ jsx13(Ribbon, {})
+            ]
+          }
+        ),
+        (phase === "idle" || phase === "preflight") && (homeScreen === "learnMore" ? /* @__PURE__ */ jsx13(LearnMore, {}) : /* @__PURE__ */ jsx13(Welcome, {}))
+      ]
+    }
+  );
+}
+
+// src/core/orchestrator.ts
+import "zod";
+
+// src/core/config.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+var configFile = () => join5(stateDir(), "config.json");
+var DEFAULT_CONFIG = {
+  version: 1,
+  aiConsent: false,
+  workflowsRun: []
+};
+async function loadConfig() {
+  try {
+    const raw = await readFile2(configFile(), "utf8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+async function saveConfig(config) {
+  await mkdir2(stateDir(), { recursive: true });
+  await writeFile2(configFile(), JSON.stringify(config, null, 2), "utf8");
+}
+async function recordWorkflowRun(workflowId, completedAt) {
+  const config = await loadConfig();
+  config.workflowsRun.push({ workflowId, completedAt });
+  await saveConfig(config);
+}
+
 // src/core/orchestrator.ts
 function defineStep(step) {
   return { visible: true, ...step };
@@ -1594,23 +1600,23 @@ function ensureExecutedStepCount(state) {
     ).length;
   }
 }
-function reconcileWorkflowState(state, workflow2) {
+function reconcileWorkflowState(state, workflow) {
   const persistedIds = state.steps.map((s) => s.id).join("\n");
-  const definedIds = workflow2.steps.map((s) => s.id).join("\n");
+  const definedIds = workflow.steps.map((s) => s.id).join("\n");
   if (persistedIds !== definedIds) return null;
   for (let i = 0; i < state.steps.length; i++) {
-    state.steps[i].title = workflow2.steps[i].title;
-    state.steps[i].visible = workflow2.steps[i].visible;
+    state.steps[i].title = workflow.steps[i].title;
+    state.steps[i].visible = workflow.steps[i].visible;
   }
   return state;
 }
-function initWorkflowState(workflow2, now) {
+function initWorkflowState(workflow, now) {
   return {
-    workflowId: workflow2.id,
+    workflowId: workflow.id,
     startedAt: now,
     updatedAt: now,
     currentStepIndex: 0,
-    steps: workflow2.steps.map((s) => ({
+    steps: workflow.steps.map((s) => ({
       id: s.id,
       title: s.title,
       visible: s.visible,
@@ -1623,8 +1629,8 @@ function initWorkflowState(workflow2, now) {
 async function ensureConsent() {
   const config = await loadConfig();
   if (config.aiConsent) return;
-  const store2 = useWizard.getState();
-  const answer = await store2.requestUserInput({
+  const store = useWizard.getState();
+  const answer = await store.requestUserInput({
     prompt: "Wizard will make AI-authored changes to this repository.",
     promptType: "enterToContinue",
     options: []
@@ -1670,7 +1676,7 @@ async function makeContext(state) {
   };
 }
 async function runStep(state, index, step, appId) {
-  const store2 = useWizard.getState();
+  const store = useWizard.getState();
   const record = state.steps[index];
   const startedAt = Date.now();
   trackActionStart({
@@ -1685,8 +1691,8 @@ async function runStep(state, index, step, appId) {
     state.executedStepCount = (state.executedStepCount ?? 0) + 1;
   }
   state.updatedAt = nowIso();
-  store2.setActiveStep(index);
-  store2.syncSteps([...state.steps], index);
+  store.setActiveStep(index);
+  store.syncSteps([...state.steps], index);
   await saveWorkflowState(state);
   await markInteraction();
   const ctx = await makeContext(state);
@@ -1696,7 +1702,7 @@ async function runStep(state, index, step, appId) {
   record.status = "done";
   record.output = output;
   state.updatedAt = nowIso();
-  store2.syncSteps([...state.steps], index);
+  store.syncSteps([...state.steps], index);
   await saveWorkflowState(state);
   trackActionEnd({
     workflowId: state.workflowId,
@@ -1706,29 +1712,29 @@ async function runStep(state, index, step, appId) {
     durationMs: Date.now() - startedAt
   });
 }
-async function runWorkflow(workflow2, appId) {
-  const store2 = useWizard.getState();
+async function runWorkflow(workflow, appId) {
+  const store = useWizard.getState();
   try {
-    const persisted = await loadWorkflowState(workflow2.id);
-    const state = (persisted && reconcileWorkflowState(persisted, workflow2)) ?? initWorkflowState(workflow2, nowIso());
+    const persisted = await loadWorkflowState(workflow.id);
+    const state = (persisted && reconcileWorkflowState(persisted, workflow)) ?? initWorkflowState(workflow, nowIso());
     ensureExecutedStepCount(state);
-    store2.startWorkflow(
+    store.startWorkflow(
       {
-        id: workflow2.id,
-        title: workflow2.title,
-        description: workflow2.description
+        id: workflow.id,
+        title: workflow.title,
+        description: workflow.description
       },
       [...state.steps]
     );
     await ensureConsent();
-    trackWorkflowStart({ workflowId: workflow2.id, appId });
-    for (let i = state.currentStepIndex; i < workflow2.steps.length; i++) {
-      await runStep(state, i, workflow2.steps[i], appId);
+    trackWorkflowStart({ workflowId: workflow.id, appId });
+    for (let i = state.currentStepIndex; i < workflow.steps.length; i++) {
+      await runStep(state, i, workflow.steps[i], appId);
     }
     const totalDurationMs = Date.now() - Date.parse(state.startedAt);
     const stepCount = state.executedStepCount ?? state.steps.filter((s) => s.status === "done" && isStepVisible(s)).length;
     trackWizardComplete({
-      workflowId: workflow2.id,
+      workflowId: workflow.id,
       appId,
       total_duration: Math.round(totalDurationMs / 1e3),
       total_steps: stepCount
@@ -1737,12 +1743,12 @@ async function runWorkflow(workflow2, appId) {
       total_duration_ms: totalDurationMs,
       step_count: stepCount
     });
-    await recordWorkflowRun(workflow2.id, nowIso());
-    await clearWorkflowState(workflow2.id);
-    store2.setDone();
+    await recordWorkflowRun(workflow.id, nowIso());
+    await clearWorkflowState(workflow.id);
+    store.setDone();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    const state = await loadWorkflowState(workflow2.id);
+    const state = await loadWorkflowState(workflow.id);
     let step = "unknown";
     let failedActionId;
     let failedActionTitle;
@@ -1754,7 +1760,7 @@ async function runWorkflow(workflow2, appId) {
           record.status = "error";
           record.error = message;
           await saveWorkflowState(state);
-          store2.syncSteps([...state.steps], state.currentStepIndex);
+          store.syncSteps([...state.steps], state.currentStepIndex);
         }
         failedActionId = record.id;
         failedActionTitle = record.title;
@@ -1762,7 +1768,7 @@ async function runWorkflow(workflow2, appId) {
     }
     if (failedActionId && failedActionTitle) {
       trackActionError({
-        workflowId: workflow2.id,
+        workflowId: workflow.id,
         appId,
         actionId: failedActionId,
         actionTitle: failedActionTitle,
@@ -1770,7 +1776,7 @@ async function runWorkflow(workflow2, appId) {
       });
     }
     trackWorkflowError({
-      workflowId: workflow2.id,
+      workflowId: workflow.id,
       appId,
       error: message,
       actionId: failedActionId
@@ -1780,7 +1786,7 @@ async function runWorkflow(workflow2, appId) {
       error: message,
       product_area: "AI Wizard"
     });
-    store2.setError(message);
+    store.setError(message);
   }
 }
 
@@ -1820,13 +1826,13 @@ async function loadActiveProfile() {
   } catch {
     profiles = [];
   }
-  const profile2 = profiles[0];
-  if (!profile2) {
+  const profile = profiles[0];
+  if (!profile) {
     throw new Error(
       "No Algolia profile is configured. Run `npx @algolia/cli auth login` to authenticate."
     );
   }
-  return profile2;
+  return profile;
 }
 
 // src/workflows/default.ts
@@ -2116,9 +2122,9 @@ function writeCredentialsTool(ctx) {
       logger.info({ filePath }, "called writeCredentials tool");
       const resolved = resolveInRoot(ctx, filePath);
       if (resolved.ok === false) return resolved.error;
-      let profile2;
+      let profile;
       try {
-        profile2 = await loadActiveProfile();
+        profile = await loadActiveProfile();
       } catch {
         return "Error: no Algolia profile is configured, so credentials cannot be written. Ask the user to authenticate with the Algolia CLI first.";
       }
@@ -2139,8 +2145,8 @@ function writeCredentialsTool(ctx) {
           return `Skipped: ${filePath} already defines ${present.join(" and ")}. Leaving existing credentials untouched.`;
         }
         const envWithCredentials = appendEnv(existing, [
-          [APP_ID_VAR, profile2.appId],
-          [API_KEY_VAR, profile2.apiKey]
+          [APP_ID_VAR, profile.appId],
+          [API_KEY_VAR, profile.apiKey]
         ]);
         await mkdir4(dirname5(resolved.target), { recursive: true });
         await writeFile4(resolved.target, envWithCredentials, "utf8");
@@ -2695,7 +2701,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.6.0",
+  version: "0.7.0-rc.57.36",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3914,27 +3920,27 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
           messages: []
         }) === true;
         if (runNow) {
-          const profile2 = await loadActiveProfile();
+          const profile = await loadActiveProfile();
           ctx.notify({ messages: [`Writing records to "${targetIndex}"\u2026`] });
           const scriptLogId = ctx.logStart("runIngestScript", {
             runtime: ingestRuntime,
             entrypoint: ingestEntrypoint
           });
           const startedAt = Date.now();
-          const run = await runIngestScript(
+          const run2 = await runIngestScript(
             worktree,
             ingestRuntime,
             ingestEntrypoint,
             {
-              [APP_ID_VAR]: profile2.appId,
-              [API_KEY_VAR]: profile2.apiKey
+              [APP_ID_VAR]: profile.appId,
+              [API_KEY_VAR]: profile.apiKey
             }
           );
-          ctx.logEnd(scriptLogId, run.ok ? "success" : "error");
-          ingestScriptRan = run.ran && run.ok;
+          ctx.logEnd(scriptLogId, run2.ok ? "success" : "error");
+          ingestScriptRan = run2.ran && run2.ok;
           if (ingestScriptRan) {
             ingestDurationMs = Date.now() - startedAt;
-            ingestRecordCount = parseIngestRecordCount(run.output);
+            ingestRecordCount = parseIngestRecordCount(run2.output);
             if (ingestRecordCount != null) {
               track("AI Wizard Ingest Successful", {
                 entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
@@ -3945,43 +3951,43 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
           }
           let summaryLine;
           let outcomeMessage;
-          if (!run.ran) {
-            summaryLine = `\u26A0\uFE0F Skipped running the ingestion script: ${run.reason}`;
-            outcomeMessage = `\u26A0\uFE0F The ingestion script did not run: ${run.reason}`;
+          if (!run2.ran) {
+            summaryLine = `\u26A0\uFE0F Skipped running the ingestion script: ${run2.reason}`;
+            outcomeMessage = `\u26A0\uFE0F The ingestion script did not run: ${run2.reason}`;
             logger.warn(
               {
                 runtime: ingestRuntime,
                 entrypoint: ingestEntrypoint,
-                reason: run.reason
+                reason: run2.reason
               },
               "implement: refused to auto-run ingestion script"
             );
             track("Error", {
               step: "Push Data",
-              error: `ingestion script skipped: ${run.reason}`,
+              error: `ingestion script skipped: ${run2.reason}`,
               product_area: "AI Wizard"
             });
-          } else if (run.ok) {
+          } else if (run2.ok) {
             const status = "Ingestion run: succeeded.";
-            summaryLine = run.output ? `${status}
-${run.output}` : status;
+            summaryLine = run2.output ? `${status}
+${run2.output}` : status;
             outcomeMessage = `\u2705 Ingestion succeeded${ingestRecordCount != null ? ` \u2014 ${ingestRecordCount} record(s) indexed.` : "."}`;
           } else {
             const status = "\u26A0\uFE0F Ingestion run failed:";
-            summaryLine = run.output ? `${status}
-${run.output}` : status;
-            outcomeMessage = `\u274C Ingestion failed.${run.output ? ` ${run.output}` : ""}`;
+            summaryLine = run2.output ? `${status}
+${run2.output}` : status;
+            outcomeMessage = `\u274C Ingestion failed.${run2.output ? ` ${run2.output}` : ""}`;
             logger.warn(
               {
                 runtime: ingestRuntime,
                 entrypoint: ingestEntrypoint,
-                output: run.output
+                output: run2.output
               },
               "implement: ingestion script run failed"
             );
             track("Error", {
               step: "Push Data",
-              error: run.output || "ingestion script exited non-zero",
+              error: run2.output || "ingestion script exited non-zero",
               product_area: "AI Wizard"
             });
           }
@@ -4171,10 +4177,10 @@ var defaultWorkflow = {
         ctx.notify({
           messages: ["Building your Algolia search experience\u2026"]
         });
-        const ingestion = ctx.getStepOutput(
+        const ingestion2 = ctx.getStepOutput(
           "ingestion"
         );
-        return implement(ctx, ["search"], ingestion?.worktreePath);
+        return implement(ctx, ["search"], ingestion2?.worktreePath);
       }
     }),
     defineStep({
@@ -4185,14 +4191,14 @@ var defaultWorkflow = {
         ctx.notify({
           messages: ["Summarizing what we did\u2026"]
         });
-        const ingestion = ctx.getStepOutput(
+        const ingestion2 = ctx.getStepOutput(
           "ingestion"
         );
         return reviewStep(ctx, {
           // The ingestion step already showed the user the exact `ingestCommand`
           // and worktree path as a notice, so nextSteps must not restate it —
           // an LLM-paraphrased command risks being wrong.
-          nextStepsGuidance: ingestion?.ingestScriptRan ? "The wizard already ran the ingestion script and records are in the index. Do NOT tell the user to run it again; instead point them at the target index to confirm the records. Do not restate the ingestion command \u2014 the wizard already showed it to them." : "Tell the user to run the ingestion script; do not restate the exact command \u2014 the wizard already showed it to them above."
+          nextStepsGuidance: ingestion2?.ingestScriptRan ? "The wizard already ran the ingestion script and records are in the index. Do NOT tell the user to run it again; instead point them at the target index to confirm the records. Do not restate the ingestion command \u2014 the wizard already showed it to them." : "Tell the user to run the ingestion script; do not restate the exact command \u2014 the wizard already showed it to them above."
         });
       }
     })
@@ -4207,38 +4213,313 @@ function getWorkflow(id) {
   return workflows[id];
 }
 
+// src/lib/seed.ts
+var projectScan2 = {
+  languages: [{ name: "TypeScript", version: "5.7.2" }],
+  frameworks: [{ name: "Next.js", version: "15.1.0" }],
+  ingestionAnalysis: [
+    {
+      name: "Product",
+      paths: ["src/models/product.ts"],
+      attributes: ["id", "name", "description", "price", "category", "brand"]
+    },
+    {
+      name: "Article",
+      paths: ["src/models/article.ts"],
+      attributes: ["id", "title", "body", "author", "tags", "publishedAt"]
+    }
+  ],
+  searchImplementationAnalysis: "src/components/Header.tsx",
+  verification: ["pnpm typecheck", "pnpm lint"]
+};
+var confirmLanguage2 = {
+  languages: projectScan2.languages
+};
+var confirmEntities2 = {
+  ingestionAnalysis: projectScan2.ingestionAnalysis,
+  confirmedEntities: [projectScan2.ingestionAnalysis[0]]
+};
+var selectIndex = {
+  selection: "wizard_seed_products"
+};
+var ingestion = {
+  filesChanged: ["algolia/ingest.mjs", "algolia/records.json", "package.json"],
+  summary: "Generated sample Product records and an ingestion script that pushes them to the target index with algoliasearch.",
+  ingestCommand: "node algolia/ingest.mjs",
+  ingestScriptRan: true,
+  ingestRecordCount: 25,
+  ingestDurationMs: 4200,
+  ingestionSource: "generated"
+};
+var confirmFramework2 = {
+  frameworks: projectScan2.frameworks
+};
+var search = {
+  filesChanged: ["src/components/Search.tsx", "src/components/Header.tsx", ".env"],
+  summary: "Added an InstantSearch-powered search box and results list, mounted in the shared header component.",
+  ingestionSource: "generated",
+  searchEnvVars: [
+    { name: "NEXT_PUBLIC_ALGOLIA_APP_ID", value: "SEEDAPPID" },
+    { name: "NEXT_PUBLIC_ALGOLIA_SEARCH_KEY", value: "seedsearchkey" }
+  ]
+};
+var review = {
+  summaryPoints: [
+    "Ingested 25 generated Product records into wizard_seed_products.",
+    "Added an InstantSearch search experience to the shared header."
+  ],
+  reviewPrompt: "Review the Algolia ingestion and search changes in this worktree.",
+  nextSteps: ["Point the ingestion script at your real product data."]
+};
+var SEEDS = {
+  default: {
+    "project-scan": projectScan2,
+    "confirm-language": confirmLanguage2,
+    "confirm-entities": confirmEntities2,
+    "select-index": selectIndex,
+    ingestion,
+    "confirm-framework": confirmFramework2,
+    search,
+    review
+  }
+};
+var SEED_USER_INPUTS = {
+  default: {
+    index: selectIndex.selection,
+    confirmedEntities: confirmEntities2.confirmedEntities,
+    ingestionAnalysis: confirmEntities2.ingestionAnalysis,
+    implementation: "success"
+  }
+};
+function formatStepList(workflow, startIndex) {
+  return workflow.steps.map((step, i) => {
+    const marker = i === startIndex ? "\u2192" : " ";
+    const hidden = step.visible ? "" : " (hidden)";
+    return `  ${marker} ${step.id} \u2014 ${step.title}${hidden}`;
+  }).join("\n");
+}
+var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString();
+function buildSeedState(workflow, startIndex) {
+  const seeds = SEEDS[workflow.id] ?? {};
+  const now = nowIso2();
+  const steps = workflow.steps.map((step, i) => {
+    const base = {
+      id: step.id,
+      title: step.title,
+      visible: step.visible,
+      status: i < startIndex ? "done" : "pending"
+    };
+    if (i >= startIndex) return base;
+    if (!(step.id in seeds)) {
+      throw new Error(
+        `No seed data for step "${step.id}" (step ${i + 1} of ${workflow.id}). Add it to SEEDS['${workflow.id}'] in src/lib/seed.ts.`
+      );
+    }
+    let output;
+    try {
+      output = step.outputSchema.parse(seeds[step.id]);
+    } catch (err) {
+      throw new Error(
+        `Seed data for step "${step.id}" does not match its outputSchema: ` + (err instanceof Error ? err.message : String(err))
+      );
+    }
+    return { ...base, output };
+  });
+  return {
+    workflowId: workflow.id,
+    startedAt: now,
+    updatedAt: now,
+    currentStepIndex: startIndex,
+    steps,
+    algoliaState: {},
+    userInputs: startIndex > 0 ? { ...SEED_USER_INPUTS[workflow.id] } : {}
+  };
+}
+async function seedWorkflowState(workflow, value) {
+  if (value === null || value.trim() === "") {
+    throw new Error("--seed requires a step id.");
+  }
+  const stepId = value.trim();
+  const startIndex = workflow.steps.findIndex((step) => step.id === stepId);
+  if (startIndex === -1) {
+    throw new Error(
+      `--seed must name a step in "${workflow.id}", got "${stepId}".` + (/^\d+$/.test(stepId) ? " Step numbers are not accepted \u2014 pass the id." : "")
+    );
+  }
+  const messages = [];
+  const config = await loadConfig();
+  if (!config.aiConsent) {
+    config.aiConsent = true;
+    await saveConfig(config);
+    messages.push("Seed: set aiConsent in the project config (skips the consent prompt).");
+  }
+  if (startIndex === 0) {
+    await clearWorkflowState(workflow.id);
+    messages.push(
+      `Seed: "${stepId}" is the first step, so this is a fresh run; cleared any existing state for "${workflow.id}".`,
+      formatStepList(workflow, startIndex)
+    );
+    return { messages };
+  }
+  const existing = await loadWorkflowState(workflow.id);
+  if (existing && existing.currentStepIndex > 0) {
+    const wasAt = workflow.steps[existing.currentStepIndex];
+    messages.push(
+      `Seed: discarded in-progress state for "${workflow.id}" (was at ${wasAt ? `"${wasAt.id}"` : "the end"}).`
+    );
+  }
+  const state = buildSeedState(workflow, startIndex);
+  await saveWorkflowState(state);
+  messages.push(
+    `Seed: "${workflow.id}" will resume at "${stepId}" with ${startIndex} step(s) pre-filled.`,
+    formatStepList(workflow, startIndex)
+  );
+  return { messages };
+}
+
+// src/lib/cli.ts
+var USAGE = `Usage: wizard [workflow-id] [options]
+
+Options:
+  --seed <step-id> Start the workflow at the step with this id, with earlier
+                   steps pre-filled with test data. Pass with no value to print
+                   the step ids. See CONTRIBUTING.md.
+  --no-telemetry   Send no telemetry or analytics for this run.
+  --reset-on-run   Wipe this project's wizard state (run state, AI consent,
+                   worktrees) before starting, so the run behaves like a
+                   first-ever run. Algolia credentials are not touched.
+  -h, --help       Print this message.`;
+function parseCliArgs(argv) {
+  const positionals = [];
+  let seed;
+  let telemetry = true;
+  let resetOnRun = false;
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--seed") {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        seed = next;
+        i++;
+      } else {
+        seed = null;
+      }
+    } else if (arg.startsWith("--seed=")) {
+      seed = arg.slice("--seed=".length);
+    } else if (arg === "--no-telemetry") {
+      telemetry = false;
+    } else if (arg === "--reset-on-run") {
+      resetOnRun = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown option "${arg}".`);
+    } else {
+      positionals.push(arg);
+    }
+  }
+  return { positionals, seed, telemetry, resetOnRun, help };
+}
+
+// src/lib/resetState.ts
+import { readdir as readdir4, rm as rm2 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+var KEEP = ["wizard.log"];
+async function resetProjectState() {
+  const dir = stateDir();
+  let entries;
+  try {
+    entries = await readdir4(dir);
+  } catch {
+    return { dir, removed: [] };
+  }
+  const targets = entries.filter((name) => !KEEP.includes(name));
+  await Promise.all(
+    targets.map((name) => rm2(join12(dir, name), { recursive: true, force: true }))
+  );
+  return { dir, removed: targets };
+}
+
 // src/main.tsx
 import { jsx as jsx14 } from "react/jsx-runtime";
-var requestedId = process.argv[2] ?? defaultWorkflow.id;
-var workflow = getWorkflow(requestedId);
-if (!workflow) {
-  const available = Object.keys(workflows).join(", ");
-  console.error(`Unknown workflow "${requestedId}". Available: ${available}`);
-  process.exit(1);
-}
-var store = useWizard.getState();
-var instance = render(/* @__PURE__ */ jsx14(App, {}), { incrementalRendering: true });
-var user = await getUser();
-if (!user) {
-  await instance.waitUntilRenderFlush();
-  instance.cleanup();
+async function startup() {
+  let args;
   try {
-    await runAuthLogin();
+    args = parseCliArgs(process.argv.slice(2));
   } catch (err) {
     console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
+    console.error(`
+${USAGE}`);
+    return 1;
   }
-  instance = render(/* @__PURE__ */ jsx14(App, {}), { incrementalRendering: true });
-  user = await getUser();
-  if (!user) {
-    store.setError(
-      "Authentication completed but no Algolia user was returned. Try running `npx @algolia/cli auth login` directly."
+  if (args.help) {
+    console.log(USAGE);
+    return 0;
+  }
+  if (!args.telemetry) {
+    process.env.WIZARD_TELEMETRY = "false";
+    console.log(
+      "Telemetry and analytics disabled for this run (--no-telemetry)."
     );
-    await instance.waitUntilExit();
-    process.exit(1);
   }
+  const requestedId = args.positionals[0] ?? defaultWorkflow.id;
+  const workflow = getWorkflow(requestedId);
+  if (!workflow) {
+    const available = Object.keys(workflows).join(", ");
+    console.error(`Unknown workflow "${requestedId}". Available: ${available}`);
+    return 1;
+  }
+  if (args.resetOnRun) {
+    const { dir, removed } = await resetProjectState();
+    console.log(
+      removed.length > 0 ? `Reset wizard state in ${dir}: ${removed.join(", ")}` : `No wizard state to reset in ${dir}`
+    );
+  }
+  if (args.seed !== void 0) {
+    try {
+      const { messages } = await seedWorkflowState(workflow, args.seed);
+      for (const message of messages) console.log(message);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      console.error(`Steps in "${workflow.id}":
+${formatStepList(workflow)}`);
+      return 1;
+    }
+  }
+  return workflow;
+}
+async function run(workflow) {
+  const store = useWizard.getState();
+  let instance = render(/* @__PURE__ */ jsx14(App, {}), { incrementalRendering: true });
+  let user = await getUser();
+  if (!user) {
+    await instance.waitUntilRenderFlush();
+    instance.cleanup();
+    try {
+      await runAuthLogin();
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+    instance = render(/* @__PURE__ */ jsx14(App, {}), { incrementalRendering: true });
+    user = await getUser();
+    if (!user) {
+      store.setError(
+        "Authentication completed but no Algolia user was returned. Try running `npx @algolia/cli auth login` directly."
+      );
+      await instance.waitUntilExit();
+      process.exit(1);
+    }
+  }
+  store.setUser(user);
+  const profile = await loadActiveProfile();
+  await store.waitForStart();
+  runWorkflow(workflow, profile?.appId);
+}
+var started = await startup();
+if (typeof started === "number") {
+  process.exitCode = started;
+} else {
+  await run(started);
 }
-store.setUser(user);
-var profile = await loadActiveProfile();
-await store.waitForStart();
-runWorkflow(workflow, profile?.appId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.6.0",
+  "version": "0.7.0-rc.57.36",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {