@algolia/wizard 0.75.0 → 0.76.0

package/dist/main.js

@@ -2234,6 +2234,7 @@ async function promptForApplication(highlight) {
 }
 async function promptToChangeApplication(currentId) {
   const store = useWizard.getState();
+  store.clearNotices();
   store.setLoadingMessage("Loading applications\u2026");
   try {
     const env = await findEnvApplicationId();
@@ -2260,7 +2261,7 @@ async function ensureApplication(resumeAppId) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.75.0",
+  version: "0.76.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -6314,6 +6315,9 @@ var defaultWorkflow = {
   ]
 };
 
+// src/workflows/playbook.ts
+import "zod";
+
 // src/actions/playbookSteps/selectPlaybook.ts
 import { z as z32 } from "zod";
 
@@ -6333,6 +6337,16 @@ var DashboardApiError = class extends Error {
     return isRecord(this.body) ? this.body : void 0;
   }
 };
+async function retryOnDashboardError(call, recover) {
+  for (; ; ) {
+    try {
+      return await call();
+    } catch (err) {
+      if (!(err instanceof DashboardApiError)) throw err;
+      await recover(err);
+    }
+  }
+}
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -6435,6 +6449,21 @@ async function getPlaybooks() {
   );
   return data;
 }
+async function createPlaybookExecution(appId, slug, indexName, options) {
+  const { data } = await dashboardRequest(
+    `/api/1/playbook-integrations/applications/${appId}/playbooks/${slug}/executions`,
+    playbookExecutionCreateResponseSchema,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        index_name: indexName,
+        force_new: options?.forceNew ?? false
+      })
+    }
+  );
+  return data;
+}
 async function createSampleIndex(appId, playbookSlug) {
   const { data } = await dashboardRequest(
     `/api/1/playbook-integrations/applications/${appId}/playbooks/${playbookSlug}/sample_index`,
@@ -6443,6 +6472,20 @@ async function createSampleIndex(appId, playbookSlug) {
   );
   return data;
 }
+async function getPlaybookExecution(uuid) {
+  const { data } = await dashboardRequest(
+    `/api/1/playbook-integrations/playbooks/executions/${uuid}`,
+    playbookExecutionSchema
+  );
+  return data;
+}
+async function assessPlaybookExecution(uuid) {
+  await dashboardRequest(
+    `/api/1/playbook-integrations/playbooks/executions/${uuid}/assess`,
+    messageResponseSchema,
+    { method: "POST" }
+  );
+}
 
 // src/actions/playbookSteps/selectPlaybook.ts
 var selectPlaybookSchema = z32.object({
@@ -6477,45 +6520,15 @@ 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";
-var SELECT_APP_OPTION = "Select app";
-async function confirmPlaybookStep(ctx) {
-  const { slug } = ctx.getStepOutput("select-playbook");
-  for (; ; ) {
-    const selection = await ctx.requestUserInput({
-      prompt: "Ready to continue?",
-      promptType: "multipleChoice",
-      options: [CONTINUE_OPTION, GO_BACK_OPTION, SELECT_APP_OPTION],
-      messages: [`Playbook: ${slug}`, `Application: ${ctx.appId}`],
-      helpText: "Going back re-opens the playbook catalogue. Select app opens the application catalogue \u2014 keep the current app to stay here, or pick another to restart the wizard."
-    });
-    if (typeof selection !== "string") {
-      throw new Error("confirm-playbook received an unexpected result");
-    }
-    if (selection === SELECT_APP_OPTION) {
-      await ctx.changeApplication();
-      continue;
-    }
-    if (selection === GO_BACK_OPTION) {
-      return ctx.returnToStep("select-playbook");
-    }
-    return;
-  }
-}
-
 // src/actions/playbookSteps/selectIndex.ts
-import { z as z34 } from "zod";
-var selectIndexSchema = z34.object({
-  indexName: z34.string(),
-  sampleIndex: z34.boolean()
+import { z as z33 } from "zod";
+var selectIndexSchema = z33.object({
+  indexName: z33.string(),
+  sampleIndex: z33.boolean()
 });
 var CREATE_SAMPLE_INDEX = "Create a sample index";
-var GO_BACK_OPTION2 = "Go back to playbook selection";
-var SELECT_APP_OPTION2 = "Select app";
+var GO_BACK_OPTION = "Go back to playbook selection";
+var SELECT_APP_OPTION = "Select app";
 var MIN_ENTRIES_FOR_SELECTION = 1;
 function formatIndexOption(index) {
   if (index.entries < MIN_ENTRIES_FOR_SELECTION) {
@@ -6541,8 +6554,8 @@ async function selectIndexStep2(ctx) {
   const options = [
     ...indexOptions,
     CREATE_SAMPLE_INDEX,
-    GO_BACK_OPTION2,
-    SELECT_APP_OPTION2
+    GO_BACK_OPTION,
+    SELECT_APP_OPTION
   ];
   const disabled = hasIndices ? [
     ...indices.map((idx) => !isIndexSelectable(idx)),
@@ -6571,11 +6584,11 @@ you can explore or switch to another application`;
         "selectIndex received an unexpected non-text result"
       );
     }
-    if (selection === GO_BACK_OPTION2) {
+    if (selection === GO_BACK_OPTION) {
       ctx.setUserInput("fetchedIndices", void 0);
       return ctx.returnToStep("select-playbook");
     }
-    if (selection === SELECT_APP_OPTION2) {
+    if (selection === SELECT_APP_OPTION) {
       await ctx.changeApplication();
       continue;
     }
@@ -6604,8 +6617,8 @@ you can explore or switch to another application`;
 // src/actions/playbookSteps/confirmIndex.ts
 import "zod";
 var confirmIndexSchema = playbookExecutionSchema.nullable();
-var CONTINUE_OPTION2 = "Looks good, continue";
-var GO_BACK_OPTION3 = "Go back";
+var CONTINUE_OPTION = "Looks good, continue";
+var GO_BACK_OPTION2 = "Go back";
 async function confirmIndexStep(ctx) {
   const { sampleIndex } = ctx.getStepOutput("select-index");
   if (!sampleIndex) {
@@ -6615,7 +6628,7 @@ async function confirmIndexStep(ctx) {
   const selection = await ctx.requestUserInput({
     prompt: "Ready to create sample index?",
     promptType: "multipleChoice",
-    options: [CONTINUE_OPTION2, GO_BACK_OPTION3],
+    options: [CONTINUE_OPTION, GO_BACK_OPTION2],
     messages: [
       `A new index called "algolia_playbooks_${slug}_sample_index" will be created with sample ${slug} data.`
     ],
@@ -6624,7 +6637,7 @@ async function confirmIndexStep(ctx) {
   if (typeof selection !== "string") {
     throw new Error("confirm-index received an unexpected result");
   }
-  if (selection === GO_BACK_OPTION3) {
+  if (selection === GO_BACK_OPTION2) {
     return ctx.returnToStep("select-index");
   }
   ctx.notify({
@@ -6654,6 +6667,227 @@ async function confirmIndexStep(ctx) {
   }
 }
 
+// src/actions/playbookSteps/dataAssessment.ts
+var CONTINUE_EXECUTION_OPTION = "Continue";
+var RESTART_OPTION = "Restart";
+var GO_BACK_OPTION3 = "Go back";
+var SWITCH_APPLICATION_OPTION = "Switch application";
+var SWITCH_INDEX_OPTION = "Switch index";
+var RETRY_OPTION = "Retry";
+var POLL_INTERVAL_MS = 5e3;
+var POLL_TIMEOUT_MS = 6e4;
+var ASSESSING_NOTICE_HOLD_MS = 2e4;
+var CREATING_EXECUTION_NOTICE = "creating playbook execution\u2026";
+var POLL_NOTICES = [
+  { message: "created playbook execution", holdMs: POLL_INTERVAL_MS },
+  { message: "sampled records", holdMs: POLL_INTERVAL_MS },
+  {
+    message: "assessing schema and readiness \u2014 this usually takes ~20s for indices under 1M records.",
+    holdMs: ASSESSING_NOTICE_HOLD_MS
+  },
+  { message: "detecting required fields\u2026" }
+];
+async function dataAssessmentStep(ctx) {
+  const { slug } = ctx.getStepOutput("select-playbook");
+  const { indexName, existingExecution } = indexForAssessment(ctx);
+  if (existingExecution) return existingExecution;
+  try {
+    showNotice(ctx, CREATING_EXECUTION_NOTICE);
+    const { id: appId } = await requireApplication();
+    const execution = await resolveExecution(ctx, appId, slug, indexName);
+    return await runAssessment(ctx, execution, indexName);
+  } finally {
+    ctx.clearNotices();
+  }
+}
+function indexForAssessment(ctx) {
+  const selected = ctx.getStepOutput("select-index");
+  if (!selected.sampleIndex) {
+    return { indexName: selected.indexName, existingExecution: null };
+  }
+  const created = ctx.getStepOutput("confirm-index");
+  if (!created) {
+    throw new Error(
+      "data-assessment expected confirm-index to create a sample index"
+    );
+  }
+  return {
+    indexName: created.source_index_name,
+    existingExecution: created
+  };
+}
+function showNotice(ctx, message) {
+  ctx.clearNotices();
+  ctx.notify({ messages: [message] });
+}
+function startPollNotices(ctx) {
+  let index = 0;
+  let timer;
+  const showCurrent = () => {
+    const notice = POLL_NOTICES[index];
+    showNotice(ctx, notice.message);
+    if (notice.holdMs == null) return;
+    timer = setTimeout(() => {
+      index += 1;
+      showCurrent();
+    }, notice.holdMs);
+  };
+  showCurrent();
+  return () => clearTimeout(timer);
+}
+async function runAssessment(ctx, execution, indexName) {
+  if (execution.step_status === "done") {
+    return execution;
+  }
+  if (execution.step_status === "not_started" || execution.step_status === "error") {
+    await assessExecution(ctx, execution.uuid, indexName);
+  } else if (execution.step_status !== "in_progress") {
+    throw unexpectedAssessmentStatus(execution.step_status);
+  }
+  for (; ; ) {
+    const assessed = await pollUntilAssessed(ctx, execution.uuid, indexName);
+    if (assessed.step_status === "done") {
+      return assessed;
+    }
+    if (assessed.step_status !== "error") {
+      throw unexpectedAssessmentStatus(assessed.step_status);
+    }
+    await promptAssessmentRecovery(
+      ctx,
+      assessmentFailureMessage(assessed),
+      assessed.status_reason === "index_empty"
+    );
+    await assessExecution(ctx, execution.uuid, indexName);
+  }
+}
+function unexpectedAssessmentStatus(status) {
+  return new Error(
+    `data-assessment received an unexpected assessment status: ${status}`
+  );
+}
+async function resolveExecution(ctx, appId, slug, indexName) {
+  const created = await createWithRecovery(ctx, appId, slug, indexName);
+  if (!created.resumed) return created;
+  const choice = await ctx.requestUserInput({
+    prompt: `${indexName} has a playbook in progress.`,
+    promptType: "multipleChoice",
+    options: [CONTINUE_EXECUTION_OPTION, RESTART_OPTION, GO_BACK_OPTION3],
+    secondary: [{ kind: "text", value: "resume Assessment" }]
+  });
+  if (choice === CONTINUE_EXECUTION_OPTION) return created;
+  if (choice === RESTART_OPTION) {
+    return createWithRecovery(ctx, appId, slug, indexName, { forceNew: true });
+  }
+  if (choice === GO_BACK_OPTION3) {
+    return ctx.returnToStep("select-index");
+  }
+  throw new Error("data-assessment received an unexpected execution choice");
+}
+async function createWithRecovery(ctx, appId, slug, indexName, options) {
+  return retryOnDashboardError(
+    () => {
+      showNotice(ctx, CREATING_EXECUTION_NOTICE);
+      return createPlaybookExecution(appId, slug, indexName, options);
+    },
+    onRequestFailure(ctx, indexName)
+  );
+}
+function onRequestFailure(ctx, indexName) {
+  return async (err) => {
+    await promptAssessmentRecovery(
+      ctx,
+      requestFailureMessage(indexName, err),
+      isEmptyIndexError(err)
+    );
+  };
+}
+function requestFailureMessage(indexName, err) {
+  if (isEmptyIndexError(err)) {
+    return `Index "${indexName}" has no records to assess.`;
+  }
+  const message = err.errorBody()?.message;
+  if (typeof message === "string" && message.trim()) return message;
+  return "Couldn't complete the request.";
+}
+function isEmptyIndexError(err) {
+  const body = err.errorBody();
+  return body?.status_reason === "index_empty" || body?.message === "index_empty";
+}
+async function pollUntilAssessed(ctx, uuid, indexName) {
+  const logId = ctx.logStart("Assessing index data");
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  let logStatus = "error";
+  let stopNotices = startPollNotices(ctx);
+  try {
+    for (; ; ) {
+      const execution = await retryOnDashboardError(
+        () => getPlaybookExecution(uuid),
+        async (err) => {
+          stopNotices();
+          ctx.clearNotices();
+          await promptAssessmentRecovery(
+            ctx,
+            requestFailureMessage(indexName, err),
+            isEmptyIndexError(err)
+          );
+          stopNotices = startPollNotices(ctx);
+        }
+      );
+      if (execution.step_status === "done") {
+        logStatus = "success";
+        return execution;
+      }
+      if (execution.step_status === "error") {
+        ctx.clearNotices();
+        return execution;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error("Timed out waiting for the data assessment to finish.");
+      }
+      await sleep(POLL_INTERVAL_MS);
+    }
+  } catch (err) {
+    ctx.clearNotices();
+    throw err;
+  } finally {
+    stopNotices();
+    ctx.logEnd(logId, logStatus);
+  }
+}
+var sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+async function assessExecution(ctx, uuid, indexName) {
+  await retryOnDashboardError(
+    () => assessPlaybookExecution(uuid),
+    onRequestFailure(ctx, indexName)
+  );
+}
+async function promptAssessmentRecovery(ctx, message, retryDisabled) {
+  const choice = await ctx.requestUserInput({
+    prompt: "Data assessment failed.",
+    promptType: "multipleChoice",
+    options: [SWITCH_APPLICATION_OPTION, SWITCH_INDEX_OPTION, RETRY_OPTION],
+    messages: [message],
+    disabled: [false, false, retryDisabled],
+    helpText: "Retry re-runs assessment on this index. Switch index or application to pick a different target."
+  });
+  if (choice === SWITCH_APPLICATION_OPTION) {
+    return ctx.changeApplication();
+  }
+  if (choice === SWITCH_INDEX_OPTION) {
+    return ctx.returnToStep("select-index");
+  }
+  if (choice === RETRY_OPTION) {
+    return;
+  }
+  throw new Error("data-assessment received an unexpected recovery choice");
+}
+function assessmentFailureMessage(execution) {
+  if (execution.status_reason === "index_empty") {
+    return `Index "${execution.source_index_name}" has no records to assess.`;
+  }
+  return execution.status_reason ?? "Data assessment failed.";
+}
+
 // src/lib/cli.ts
 var USAGE = `Usage: wizard [workflow-id] [options]
        wizard playbook [playbook-slug] [options]
@@ -6721,13 +6955,6 @@ var playbookWorkflow = {
       outputSchema: selectPlaybookSchema,
       run: (ctx) => selectPlaybookStep(ctx, getPlaybookSlugArg())
     }),
-    defineStep({
-      id: "confirm-playbook",
-      title: "Confirm selections",
-      outputSchema: confirmPlaybookSchema,
-      visible: false,
-      run: (ctx) => confirmPlaybookStep(ctx)
-    }),
     defineStep({
       id: "select-index",
       title: "Select index",
@@ -6742,6 +6969,12 @@ var playbookWorkflow = {
       visible: false,
       tips: ["apps-and-indices", "records-are-json", "speed"],
       run: (ctx) => confirmIndexStep(ctx)
+    }),
+    defineStep({
+      id: "data-assessment",
+      title: "Assess index data",
+      outputSchema: playbookExecutionSchema,
+      run: (ctx) => dataAssessmentStep(ctx)
     })
   ]
 };
@@ -7637,7 +7870,7 @@ function App() {
   const isCommandApprovalPrompt = isAwaitingUserInput && inputReq?.promptType === "commandApproval";
   const promptPending = isAwaitingUserInput && !isCommandApprovalPrompt;
   const holdForTip = stepHasTips && promptPending && tipState === "revealing";
-  const showTips = stepHasTips && (phase === "running" && currentStep?.status === "running" || isCommandApprovalPrompt || holdForTip);
+  const showTips = stepHasTips && (phase === "running" && currentStep?.status === "running" && !loadingMessage && !settingUpAppId || isCommandApprovalPrompt);
   const showNoticesInMain = !stepHasTips;
   const showNotices = (!isAwaitingUserInput || holdForTip) && !review2;
   useInput9(
@@ -7826,6 +8059,23 @@ var selectPlaybookIndex = {
   indexName: "wizard_seed_orders",
   sampleIndex: false
 };
+var dataAssessment = {
+  uuid: "seed-exec-uuid",
+  playbook_slug: selectPlaybook.slug,
+  application_id: "SEEDAPPID",
+  source_index_name: selectPlaybookIndex.indexName,
+  current_step: "assessment",
+  step_status: "done",
+  status_reason: null,
+  completed: true,
+  assessment_result: {
+    ready: true,
+    schema_comparison: [],
+    settings_recommendation: {}
+  },
+  settings_snapshot: null,
+  created_at: "2026-09-22T09:00:00.000Z"
+};
 var review = {
   summaryPoints: [
     "Ingested 25 generated Product records into wizard_seed_products.",
@@ -7847,9 +8097,9 @@ var SEEDS = {
   },
   playbook: {
     "select-playbook": selectPlaybook,
-    "confirm-playbook": void 0,
     "select-index": selectPlaybookIndex,
-    "confirm-index": null
+    "confirm-index": null,
+    "data-assessment": dataAssessment
   }
 };
 var SEED_ALGOLIA_STATE = {
@@ -8020,7 +8270,7 @@ function delay(ms) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.75.0",
+  version: "0.76.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/package.json

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