@algolia/wizard 0.62.0 → 0.64.0

package/dist/main.js

@@ -1697,29 +1697,153 @@ function trackWorkflowError(ctx) {
 
 // src/lib/events.ts
 import "zod";
-function track(event, payload) {
+var analyticsAppId = void 0;
+var analyticsAgentRunId = void 0;
+function setAnalyticsContext(next) {
+  analyticsAppId = next.appId;
+  analyticsAgentRunId = next.agentRunId;
+}
+function wizardErrorType(actionId, step, error) {
+  if (actionId === "project-scan" || step === "project scan") {
+    return "Scan Codebase";
+  }
+  if (actionId === "ingestion" || step === "Push Data" || step === "ingest records") {
+    return "Ingest Records";
+  }
+  if (actionId === "search" || step === "create search ui") {
+    if (error && error.toLowerCase().includes("verification failed")) {
+      return "Wire Component to UI";
+    }
+    return "Generate UI";
+  }
+  return void 0;
+}
+function commonEventProperties() {
+  const properties = {};
+  if (analyticsAppId) properties.app_id = analyticsAppId;
+  if (analyticsAgentRunId) properties.agent_run_id = analyticsAgentRunId;
+  return properties;
+}
+function postAnalytics(path, body, label) {
   if (isTelemetryOptedOut()) return;
   const token = getAuthToken();
   if (!token) return;
   const userId = useWizard.getState().user?.userId;
   if (!userId) return;
-  void proxyFetch(`${PROXY_BASE_URL}/events`, {
+  void proxyFetch(`${PROXY_BASE_URL}${path}`, {
     method: "POST",
     headers: {
       "content-type": "application/json",
       authorization: `Bearer ${token}`
     },
-    body: JSON.stringify({ userId, event, properties: payload })
+    body: JSON.stringify(body)
   }).catch((err) => {
-    logger.warn({ err, event }, "failed to send analytics event");
+    logger.warn({ err, event: label }, "failed to send analytics event");
   });
 }
+function track(event, payload) {
+  postAnalytics(
+    "/events",
+    {
+      userId: useWizard.getState().user?.userId,
+      event,
+      properties: { ...payload, ...commonEventProperties() }
+    },
+    event
+  );
+}
+function identify(traits) {
+  const userId = useWizard.getState().user?.userId;
+  postAnalytics("/identify", { userId, traits }, "identify");
+}
+
+// package.json
+var package_default = {
+  name: "@algolia/wizard",
+  version: "0.64.0",
+  description: "Magically implement Algolia functionality in your codebase",
+  type: "module",
+  engines: {
+    node: ">=24"
+  },
+  bin: {
+    wizard: "dist/main.js"
+  },
+  files: [
+    "dist",
+    "docs"
+  ],
+  scripts: {
+    "build:proxy": "node scripts/build.mjs proxy",
+    build: "node scripts/build.mjs",
+    "dev:proxy": "touch .env && NODE_OPTIONS=--use-system-ca tsx watch --env-file=.env src/proxy/index.ts",
+    dev: "touch .env && tsx --env-file=.env ./src/main.tsx",
+    "env:load": "pnpm exec -- varlock load",
+    prepare: "husky",
+    prepublishOnly: "pnpm build",
+    reset: "tsx ./scripts/reset-state.ts",
+    "test:fixtures": "touch .env && tsx --env-file=.env ./fixtures/run-fixtures.ts",
+    "test:tools": "tsx ./tool-evals/toolEval.ts",
+    "test:tools:improve": "tsx ./tool-evals/improveFromPlan.ts",
+    test: "vitest",
+    typecheck: "tsc --noEmit -p tsconfig.json"
+  },
+  keywords: [],
+  author: "",
+  license: "ISC",
+  packageManager: "pnpm@11.9.0+sha512.bd682d5d03fe525ef7c9fd6780c6884d1e756ac4c9c9fe00c538782824310dcf90e3ddc4f53835f06dfaebd5085e41855e0bcbb3b60de2ac5bbab89e5036f03b",
+  devDependencies: {
+    "@clack/prompts": "^1.6.0",
+    "@types/ioredis-mock": "^8.2.7",
+    "@types/node": "^25.9.1",
+    "@types/react": "^19.2.16",
+    esbuild: "^0.28.0",
+    husky: "^9.1.7",
+    "ink-testing-library": "^4.0.0",
+    "ioredis-mock": "^8.13.1",
+    "lint-staged": "^17.0.8",
+    tsx: "^4.22.3",
+    typescript: "^6.0.3",
+    vitest: "^4.1.8"
+  },
+  dependencies: {
+    "@ai-sdk/anthropic": "^3.0.81",
+    "@ai-sdk/openai-compatible": "^2.0.47",
+    "@hono/node-server": "^2.0.10",
+    "@segment/analytics-node": "^3.1.0",
+    ai: "^6.0.190",
+    "cross-keychain": "^1.1.0",
+    dotenv: "^17.4.2",
+    hono: "^4.12.27",
+    ink: "^7.0.5",
+    "ink-picture": "^2.1.0",
+    "ink-spinner": "^5.0.0",
+    ioredis: "^5.11.1",
+    nanoid: "^5.1.15",
+    pino: "^10.3.1",
+    react: "^19.2.7",
+    "terminal-link": "^5.0.0",
+    varlock: "^1.5.1",
+    zod: "^4.4.3",
+    zustand: "^5.0.14"
+  }
+};
 
 // src/core/orchestrator.ts
 function defineStep(step) {
   return { visible: true, ...step };
 }
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var ReturnToStepSignal = class extends Error {
+  constructor(targetIndex, stepId) {
+    super(`returnToStep: ${stepId}`);
+    this.targetIndex = targetIndex;
+    this.stepId = stepId;
+    this.name = "ReturnToStepSignal";
+  }
+  targetIndex;
+  stepId;
+};
 function ensureExecutedStepCount(state) {
   if (state.executedStepCount == null) {
     state.executedStepCount = state.steps.filter(
@@ -1766,9 +1890,37 @@ function initWorkflowState(workflow, now, appId) {
       status: "pending"
     })),
     algoliaState: appId ? { appId } : {},
-    userInputs: {}
+    userInputs: {},
+    agentRunId: crypto.randomUUID()
   };
 }
+function ensureAgentRunId(state) {
+  if (!state.agentRunId) state.agentRunId = crypto.randomUUID();
+}
+function completeEventProperties(state, totalDurationMs, stepCount) {
+  const indexName = state.steps.find((s) => s.id === "select-index")?.output?.selection;
+  const framework = state.steps.find((s) => s.id === "confirm-framework")?.output?.frameworks?.[0]?.name;
+  return {
+    total_duration_ms: totalDurationMs,
+    duration_ms: totalDurationMs,
+    step_count: stepCount,
+    index_name: indexName ?? "unknown",
+    framework: framework ?? "unknown"
+  };
+}
+function errorCodeFrom(err) {
+  let current = err;
+  for (let i = 0; i < 4 && current; i++) {
+    if (current && typeof current === "object" && "statusCode" in current) {
+      const code = current.statusCode;
+      if (typeof code === "number" || typeof code === "string") {
+        return String(code);
+      }
+    }
+    current = current instanceof Error ? current.cause : void 0;
+  }
+  return void 0;
+}
 async function ensureConsent() {
   const config = await loadConfig();
   if (config.aiConsent) return;
@@ -1812,12 +1964,37 @@ async function makeContext(state) {
     setUserInput: (key, value) => {
       state.userInputs[key] = value;
     },
+    getUserInput: (key) => state.userInputs[key],
     recordStepExecution: (count = 1) => {
       state.executedStepCount = (state.executedStepCount ?? 0) + count;
     },
+    returnToStep: (stepId) => {
+      const targetIndex = state.steps.findIndex((s) => s.id === stepId);
+      if (targetIndex === -1) {
+        throw new Error(`returnToStep: unknown step id "${stepId}"`);
+      }
+      if (targetIndex >= state.currentStepIndex) {
+        throw new Error(
+          `returnToStep: "${stepId}" is not before the running step "${state.steps[state.currentStepIndex]?.id}"`
+        );
+      }
+      throw new ReturnToStepSignal(targetIndex, stepId);
+    },
     config: await loadConfig()
   };
 }
+async function rewindTo(state, targetIndex, fromIndex) {
+  for (let i = targetIndex; i <= fromIndex; i++) {
+    const record = state.steps[i];
+    record.status = "pending";
+    delete record.output;
+    delete record.error;
+  }
+  state.currentStepIndex = targetIndex;
+  state.updatedAt = nowIso();
+  useWizard.getState().syncSteps([...state.steps], targetIndex);
+  await saveWorkflowState(state);
+}
 async function runStep(state, index, step, appId) {
   const store = useWizard.getState();
   const record = state.steps[index];
@@ -1839,9 +2016,18 @@ async function runStep(state, index, step, appId) {
   await saveWorkflowState(state);
   await markInteraction();
   const ctx = await makeContext(state);
-  const raw = await step.run(ctx);
-  const output = step.outputSchema.parse(raw);
-  await step.onStepComplete?.(output, ctx);
+  let output;
+  try {
+    const raw = await step.run(ctx);
+    output = step.outputSchema.parse(raw);
+    await step.onStepComplete?.(output, ctx);
+  } catch (err) {
+    if (err instanceof ReturnToStepSignal) {
+      await rewindTo(state, err.targetIndex, index);
+      return err.targetIndex;
+    }
+    throw err;
+  }
   record.status = "done";
   record.output = output;
   state.updatedAt = nowIso();
@@ -1854,6 +2040,7 @@ async function runStep(state, index, step, appId) {
     actionTitle: step.title,
     durationMs: Date.now() - startedAt
   });
+  return void 0;
 }
 var RESUME_OPTION = "Resume";
 var START_NEW_OPTION = "Start a new one";
@@ -1881,6 +2068,8 @@ async function runWorkflow(workflow, appId, options) {
   try {
     const state = await resolveWorkflowState(workflow, appId, options);
     ensureExecutedStepCount(state);
+    ensureAgentRunId(state);
+    setAnalyticsContext({ appId, agentRunId: state.agentRunId });
     store.startWorkflow(
       {
         id: workflow.id,
@@ -1891,8 +2080,15 @@ async function runWorkflow(workflow, appId, options) {
     );
     await ensureConsent();
     trackWorkflowStart({ workflowId: workflow.id, appId });
-    for (let i = state.currentStepIndex; i < workflow.steps.length; i++) {
-      await runStep(state, i, workflow.steps[i], appId);
+    track("AI Wizard Started", {
+      version: package_default.version,
+      wizard_version: package_default.version,
+      os: process.platform
+    });
+    let i = state.currentStepIndex;
+    while (i < workflow.steps.length) {
+      const rewoundTo = await runStep(state, i, workflow.steps[i], appId);
+      i = rewoundTo ?? i + 1;
     }
     const totalDurationMs = Date.now() - Date.parse(state.startedAt);
     const stepCount = state.executedStepCount ?? state.steps.filter((s) => s.status === "done" && isStepVisible(s)).length;
@@ -1902,10 +2098,11 @@ async function runWorkflow(workflow, appId, options) {
       total_duration: Math.round(totalDurationMs / 1e3),
       total_steps: stepCount
     });
-    track("AI Wizard Complete", {
-      total_duration_ms: totalDurationMs,
-      step_count: stepCount
-    });
+    track(
+      "AI Wizard Completed",
+      completeEventProperties(state, totalDurationMs, stepCount)
+    );
+    identify({ is_Wizard_user: true });
     await recordWorkflowRun(workflow.id, nowIso());
     await clearWorkflowState(workflow.id);
     store.setDone();
@@ -1946,10 +2143,15 @@ async function runWorkflow(workflow, appId, options) {
       actionId: failedActionId,
       cause: err
     });
+    const errorType = wizardErrorType(failedActionId, step, message);
+    const errorCode2 = errorCodeFrom(err);
     track("Error", {
       step,
       error: message,
-      product_area: "AI Wizard"
+      error_message: message,
+      product_area: "AI Wizard",
+      ...errorType ? { error_type: errorType } : {},
+      ...errorCode2 ? { error_code: errorCode2 } : {}
     });
     store.setError(message);
   }
@@ -3529,7 +3731,7 @@ function generateRecordTool(ctx, createModel = defaultCreateModel2) {
       try {
         const anthropic = createModel();
         const value = z17.union([z17.string(), z17.number(), z17.boolean(), z17.null()]);
-        const recordSchema = z17.object(
+        const recordSchema2 = z17.object(
           Object.fromEntries(attributes.map((attr) => [attr, value]))
         );
         const generateBatch = async (batchCount) => {
@@ -3540,7 +3742,7 @@ function generateRecordTool(ctx, createModel = defaultCreateModel2) {
                 model: anthropic(RECORD_MODEL),
                 output: Output2.object({
                   schema: z17.object({
-                    records: z17.array(recordSchema).length(batchCount)
+                    records: z17.array(recordSchema2).length(batchCount)
                   })
                 }),
                 prompt: [
@@ -3975,78 +4177,6 @@ async function runAnalysis(mode, extraInstructions = []) {
   return Object.assign({}, ...results);
 }
 
-// package.json
-var package_default = {
-  name: "@algolia/wizard",
-  version: "0.62.0",
-  description: "Magically implement Algolia functionality in your codebase",
-  type: "module",
-  engines: {
-    node: ">=24"
-  },
-  bin: {
-    wizard: "dist/main.js"
-  },
-  files: [
-    "dist",
-    "docs"
-  ],
-  scripts: {
-    "build:proxy": "node scripts/build.mjs proxy",
-    build: "node scripts/build.mjs",
-    "dev:proxy": "touch .env && NODE_OPTIONS=--use-system-ca tsx watch --env-file=.env src/proxy/index.ts",
-    dev: "touch .env && tsx --env-file=.env ./src/main.tsx",
-    "env:load": "pnpm exec -- varlock load",
-    prepare: "husky",
-    prepublishOnly: "pnpm build",
-    reset: "tsx ./scripts/reset-state.ts",
-    "test:fixtures": "touch .env && tsx --env-file=.env ./fixtures/run-fixtures.ts",
-    "test:tools": "tsx ./tool-evals/toolEval.ts",
-    "test:tools:improve": "tsx ./tool-evals/improveFromPlan.ts",
-    test: "vitest",
-    typecheck: "tsc --noEmit -p tsconfig.json"
-  },
-  keywords: [],
-  author: "",
-  license: "ISC",
-  packageManager: "pnpm@11.9.0+sha512.bd682d5d03fe525ef7c9fd6780c6884d1e756ac4c9c9fe00c538782824310dcf90e3ddc4f53835f06dfaebd5085e41855e0bcbb3b60de2ac5bbab89e5036f03b",
-  devDependencies: {
-    "@clack/prompts": "^1.6.0",
-    "@types/ioredis-mock": "^8.2.7",
-    "@types/node": "^25.9.1",
-    "@types/react": "^19.2.16",
-    esbuild: "^0.28.0",
-    husky: "^9.1.7",
-    "ink-testing-library": "^4.0.0",
-    "ioredis-mock": "^8.13.1",
-    "lint-staged": "^17.0.8",
-    tsx: "^4.22.3",
-    typescript: "^6.0.3",
-    vitest: "^4.1.8"
-  },
-  dependencies: {
-    "@ai-sdk/anthropic": "^3.0.81",
-    "@ai-sdk/openai-compatible": "^2.0.47",
-    "@hono/node-server": "^2.0.10",
-    "@segment/analytics-node": "^3.1.0",
-    ai: "^6.0.190",
-    "cross-keychain": "^1.1.0",
-    dotenv: "^17.4.2",
-    hono: "^4.12.27",
-    ink: "^7.0.5",
-    "ink-picture": "^2.1.0",
-    "ink-spinner": "^5.0.0",
-    ioredis: "^5.11.1",
-    nanoid: "^5.1.15",
-    pino: "^10.3.1",
-    react: "^19.2.7",
-    "terminal-link": "^5.0.0",
-    varlock: "^1.5.1",
-    zod: "^4.4.3",
-    zustand: "^5.0.14"
-  }
-};
-
 // src/actions/projectScan.ts
 import "zod";
 var projectScanSchema = detectLanguageSchema.extend({
@@ -4055,16 +4185,19 @@ var projectScanSchema = detectLanguageSchema.extend({
   verification: analyzeCodebaseSchema.shape.verification
 });
 async function projectScan(ctx) {
+  const startedAt = Date.now();
   const [detected, analyses] = await Promise.all([
     detectLanguage(),
     runAnalysis()
   ]);
-  track("AI Wizard Started", {
-    wizard_version: package_default.version,
-    os: process.platform
-  });
+  const entities = toEntitySummary(analyses.ingestionAnalysis ?? []);
   track("AI Wizard Scan Completed", {
-    entities: toEntitySummary(analyses.ingestionAnalysis ?? [])
+    languages: detected.languages,
+    frameworks: detected.frameworks,
+    data_models_found: entities.map((entity) => entity.name),
+    back_end_language_detected: detected.languages[0]?.name ?? null,
+    front_end_framework_detected: detected.frameworks[0]?.name ?? null,
+    duration_ms: Date.now() - startedAt
   });
   for (const [key, value] of Object.entries(analyses)) {
     ctx.setUserInput(key, value);
@@ -4162,7 +4295,7 @@ var isSameFramework = (a, b) => {
 };
 function confirmed(name, version) {
   const frameworks = [{ name, version: version ?? "unknown" }];
-  track("AI Wizard Frontend Framework Confirmed", { frameworks });
+  track("AI Wizard Frontend Framework Confirmed", { frameworks, framework: name });
   return { frameworks };
 }
 async function askOtherFramework(ctx) {
@@ -4266,6 +4399,11 @@ var confirmEntitiesSchema = z26.object({
   confirmedEntities: confirmedEntitiesFieldSchema
 });
 var SUGGEST_ENTITY = "Suggest a different entity\u2026";
+function usedDetectedBackend(detected, confirmed2) {
+  if (!detected?.length || !confirmed2?.length) return false;
+  const detectedNames = new Set(detected.map((entry) => entry.name.toLowerCase()));
+  return confirmed2.every((entry) => detectedNames.has(entry.name.toLowerCase()));
+}
 async function askEntityName(ctx, opts) {
   const blankHint = opts?.blankHint ?? "cancel";
   const declared = await promptUser(ctx, {
@@ -4372,8 +4510,14 @@ async function confirmEntities(ctx) {
       throw new Error("User cancelled entity selection \u2014 analysis halted.");
     }
     ctx.setUserInput("confirmedEntities", confirmed2);
-    track("AI Wizard Entities Confirmed", {
-      entities: toEntitySummary(confirmed2)
+    const languages = ctx.getStepOutput(
+      "confirm-language"
+    )?.languages;
+    const summary = toEntitySummary(confirmed2);
+    track("AI Wizard Data Model Confirmed", {
+      data_model: summary[0]?.name ?? "unknown",
+      attribute_count: summary[0]?.attributes.length ?? 0,
+      used_detected_back_end: usedDetectedBackend(scan.languages, languages)
     });
     return { ingestionAnalysis: entities, confirmedEntities: confirmed2 };
   }
@@ -4423,7 +4567,7 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 
 // src/actions/implement.ts
 import z28 from "zod";
-import { mkdir as mkdir5 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile8 } from "node:fs/promises";
 import { join as join10, relative as relative6 } from "node:path";
 
 // src/lib/git.ts
@@ -4812,6 +4956,50 @@ function outputTail(output) {
   if (!trimmed) return void 0;
   return trimmed.length > INGEST_OUTPUT_TAIL_CHARS ? `\u2026${trimmed.slice(-INGEST_OUTPUT_TAIL_CHARS)}` : trimmed;
 }
+function jsTypeName(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean" || type === "object") {
+    return type;
+  }
+  return "unknown";
+}
+async function firstRecordIn(filePath) {
+  try {
+    const parsed = JSON.parse(await readFile8(filePath, "utf8"));
+    const first = Array.isArray(parsed) ? parsed[0] : parsed;
+    if (first && typeof first === "object" && !Array.isArray(first)) {
+      return first;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+async function ingestedRecordSample(repoRoot, entityName, uploadFilePath) {
+  const candidates = [];
+  if (entityName) {
+    const slug = entityName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    candidates.push(join10(repoRoot, INGEST_DIR, "data", `${slug}.json`));
+  }
+  if (uploadFilePath?.toLowerCase().endsWith(".json")) {
+    candidates.push(join10(repoRoot, uploadFilePath));
+  }
+  for (const candidate of candidates) {
+    const sample = await firstRecordIn(candidate);
+    if (sample) return sample;
+  }
+  return void 0;
+}
+function recordSchema(sample, attributes) {
+  if (sample) {
+    return Object.fromEntries(
+      Object.entries(sample).map(([key, value]) => [key, jsTypeName(value)])
+    );
+  }
+  return Object.fromEntries(attributes.map((key) => [key, "unknown"]));
+}
 function ingestFailure(attempt, executions) {
   if (!attempt) {
     return {
@@ -5041,11 +5229,24 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     if (ingestScriptRan) {
       ingestOutcomeMessage = `\u2705 Ingestion succeeded${ingestRecordCount != null ? ` \u2014 ${ingestRecordCount} record(s) indexed.` : "."}`;
       if (ingestRecordCount != null) {
+        const data_model = confirmed2?.[0]?.name ?? "unknown";
+        const sample = await ingestedRecordSample(
+          repoRoot,
+          confirmed2?.[0]?.name,
+          uploadFilePath
+        );
         track("AI Wizard Ingest Successful", {
-          entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
+          data_model,
           record_count: ingestRecordCount,
-          duration_ms: ingestDurationMs ?? 0
+          duration_ms: ingestDurationMs ?? 0,
+          index_name: targetIndex,
+          record_schema: recordSchema(sample, confirmed2?.[0]?.attributes ?? [])
         });
+      } else {
+        logger.warn(
+          { ingestCommand },
+          "implement: ingestion ran but printed no record count; skipping Ingest Successful event"
+        );
       }
     } else {
       const { reason, detail } = ingestFailure(ingestAttempt, executions);
@@ -5069,7 +5270,10 @@ ${detail}` : ""}`
       track("Error", {
         step: "Push Data",
         error: `ingestion did not complete: ${reason}`,
-        product_area: "AI Wizard"
+        error_message: `ingestion did not complete: ${reason}`,
+        error_type: "Ingest Records",
+        product_area: "AI Wizard",
+        ...ingestAttempt?.exitCode != null ? { error_code: String(ingestAttempt.exitCode) } : {}
       });
     }
     if (ingestScriptRan) {
@@ -5103,6 +5307,29 @@ ${detail}` : ""}`
   let searchConfigFile;
   if (useCases.includes("search")) {
     let extraInstructions = [];
+    const confirmedFrameworks = language.frameworks ?? [];
+    const detectedFrameworks = scan.frameworks ?? [];
+    const framework = confirmedFrameworks[0]?.name ?? "unknown";
+    const used_detected_framework = confirmedFrameworks.some(
+      (confirmedFw) => detectedFrameworks.some(
+        (detectedFw) => isSameFramework(confirmedFw.name, detectedFw.name)
+      )
+    );
+    const searchStartedAt = Date.now();
+    const trackComponentGenerated = (mounted_successfully, attempts) => {
+      const searchFilesChanged = [
+        ...new Set(useWizard.getState().writtenFiles)
+      ].map((file) => relative6(repoRoot, file));
+      track("AI Wizard Frontend Component Generated", {
+        file_paths: searchFilesChanged,
+        framework,
+        duration_ms: Date.now() - searchStartedAt,
+        used_detected_framework,
+        mounted_successfully,
+        location_heuristic: searchLocation ?? "unknown",
+        attempts
+      });
+    };
     useWizard.getState().clearWrittenFiles();
     for (let attempt = 1; attempt <= MAX_IMPLEMENT_VERIFICATION_ATTEMPTS; attempt++) {
       if (attempt > 1) {
@@ -5127,19 +5354,12 @@ ${detail}` : ""}`
       summaries.push(formatSummary("verification", verification.summary));
       if (verification.sufficient) {
         ctx.setUserInput("implementation", "success");
-        const searchFilesChanged = [
-          ...new Set(useWizard.getState().writtenFiles)
-        ].map((file) => relative6(repoRoot, file));
-        track("AI Wizard Frontend Component Generated", {
-          filePaths: searchFilesChanged
-        });
-        track("AI Wizard Wired to UI", {
-          location_heuristic: searchLocation ?? "unknown"
-        });
+        trackComponentGenerated(true, attempt);
         break;
       }
       if (attempt === MAX_IMPLEMENT_VERIFICATION_ATTEMPTS) {
         ctx.setUserInput("implementation", "fail");
+        trackComponentGenerated(false, attempt);
         throw new Error(
           `Implementation verification failed after ${MAX_IMPLEMENT_VERIFICATION_ATTEMPTS} attempts: ${verification.additionalInstructions ?? verification.summary}`
         );
@@ -5356,10 +5576,11 @@ async function selectPlaybookStep(ctx, requestedSlug) {
   if (slugs.length === 0) {
     throw new Error("No playbooks are available.");
   }
-  if (requestedSlug && slugs.includes(requestedSlug)) {
+  const alreadyChose = typeof ctx.getUserInput("playbookSlug") === "string";
+  if (!alreadyChose && requestedSlug && slugs.includes(requestedSlug)) {
     return persistSlug(ctx, requestedSlug);
   }
-  const messages = requestedSlug ? [
+  const messages = !alreadyChose && requestedSlug ? [
     `"${requestedSlug}" is not a valid playbook. Choose one of the available playbooks:`
   ] : ["Choose a playbook:"];
   const selection = await ctx.requestUserInput({
@@ -5374,6 +5595,28 @@ async function selectPlaybookStep(ctx, requestedSlug) {
   return persistSlug(ctx, selection);
 }
 
+// src/actions/playbookSteps/confirmPlaybook.ts
+import { z as z33 } from "zod";
+var confirmPlaybookSchema = z33.void();
+var CONTINUE_OPTION = "Looks good, continue";
+var GO_BACK_OPTION = "Go back";
+async function confirmPlaybookStep(ctx) {
+  const { slug } = ctx.getStepOutput("select-playbook");
+  const selection = await ctx.requestUserInput({
+    prompt: "Ready to continue?",
+    promptType: "multipleChoice",
+    options: [CONTINUE_OPTION, GO_BACK_OPTION],
+    messages: [`Playbook: ${slug}`],
+    helpText: "Going back re-opens the playbook catalogue."
+  });
+  if (typeof selection !== "string") {
+    throw new Error("confirm-playbook received an unexpected result");
+  }
+  if (selection === GO_BACK_OPTION) {
+    return ctx.returnToStep("select-playbook");
+  }
+}
+
 // src/lib/cli.ts
 var USAGE = `Usage: wizard [workflow-id] [options]
        wizard playbook [playbook-slug] [options]
@@ -5440,6 +5683,13 @@ var playbookWorkflow = {
       title: "Select playbook",
       outputSchema: selectPlaybookSchema,
       run: (ctx) => selectPlaybookStep(ctx, getPlaybookSlugArg())
+    }),
+    defineStep({
+      id: "confirm-playbook",
+      title: "Confirm selections",
+      outputSchema: confirmPlaybookSchema,
+      visible: false,
+      run: (ctx) => confirmPlaybookStep(ctx)
     })
   ]
 };
@@ -6459,7 +6709,7 @@ function App() {
 }
 
 // src/lib/envAppId.ts
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 import { join as join12 } from "node:path";
 var ENV_FILES = [".env", ".env.local"];
 var APP_ID_LINE = /^[ \t]*(?:export[ \t]+)?([A-Z0-9_]*ALGOLIA_APP(?:LICATION)?_ID)[ \t]*=[ \t]*(.*)$/gm;
@@ -6467,7 +6717,7 @@ async function findEnvApplicationId(root = process.cwd()) {
   for (const file of ENV_FILES) {
     let content;
     try {
-      content = await readFile8(join12(root, file), "utf8");
+      content = await readFile9(join12(root, file), "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         logger.warn(
@@ -6654,9 +6904,13 @@ var SEEDS = {
     review
   },
   playbook: {
-    "select-playbook": selectPlaybook
+    "select-playbook": selectPlaybook,
+    "confirm-playbook": void 0
   }
 };
+var SEED_ALGOLIA_STATE = {
+  playbook: { appId: "SEEDAPPID" }
+};
 var SEED_USER_INPUTS = {
   default: {
     index: selectIndex.selection,
@@ -6708,7 +6962,7 @@ function buildSeedState(workflow, startIndex) {
     updatedAt: now,
     currentStepIndex: startIndex,
     steps,
-    algoliaState: {},
+    algoliaState: startIndex > 0 ? { ...SEED_ALGOLIA_STATE[workflow.id] } : {},
     userInputs: startIndex > 0 ? { ...SEED_USER_INPUTS[workflow.id] } : {}
   };
 }
@@ -6820,7 +7074,7 @@ function delay(ms) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.62.0",
+  version: "0.64.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.62.0",
+  "version": "0.64.0",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {