@algolia/wizard 0.74.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.74.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,43 @@ 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`,
+    playbookExecutionSchema,
+    { method: "POST" }
+  );
+  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({
@@ -6469,34 +6520,372 @@ async function selectPlaybookStep(ctx, requestedSlug) {
   return persistSlug(ctx, selection);
 }
 
-// src/actions/playbookSteps/confirmPlaybook.ts
+// src/actions/playbookSteps/selectIndex.ts
 import { z as z33 } from "zod";
-var confirmPlaybookSchema = z33.void();
-var CONTINUE_OPTION = "Looks good, continue";
-var GO_BACK_OPTION = "Go back";
+var selectIndexSchema = z33.object({
+  indexName: z33.string(),
+  sampleIndex: z33.boolean()
+});
+var CREATE_SAMPLE_INDEX = "Create a sample index";
+var GO_BACK_OPTION = "Go back to playbook selection";
 var SELECT_APP_OPTION = "Select app";
-async function confirmPlaybookStep(ctx) {
-  const { slug } = ctx.getStepOutput("select-playbook");
-  for (; ; ) {
+var MIN_ENTRIES_FOR_SELECTION = 1;
+function formatIndexOption(index) {
+  if (index.entries < MIN_ENTRIES_FOR_SELECTION) {
+    return `${index.name} (empty index)`;
+  }
+  return `${index.name} (${index.entries.toLocaleString()} records)`;
+}
+function isIndexSelectable(index) {
+  return index.entries >= MIN_ENTRIES_FOR_SELECTION;
+}
+async function selectIndexStep2(ctx) {
+  let indices = ctx.getUserInput("fetchedIndices");
+  !indices && ctx.notify({
+    messages: ["Fetching indices from your Algolia application\u2026"]
+  });
+  const app = await requireApplication();
+  if (!indices) {
+    indices = await listIndices();
+    ctx.setUserInput("fetchedIndices", indices);
+  }
+  const hasIndices = indices.length > 0;
+  const indexOptions = hasIndices ? indices.map(formatIndexOption) : [];
+  const options = [
+    ...indexOptions,
+    CREATE_SAMPLE_INDEX,
+    GO_BACK_OPTION,
+    SELECT_APP_OPTION
+  ];
+  const disabled = hasIndices ? [
+    ...indices.map((idx) => !isIndexSelectable(idx)),
+    false,
+    // CREATE_SAMPLE_INDEX is selectable
+    false,
+    // GO_BACK_OPTION is selectable
+    false
+    // SELECT_APP_OPTION is selectable
+  ] : void 0;
+  const prompt = hasIndices ? "Select an index:" : `${app.name} doesn't have any indices yet. Start from a sample data set 
+you can explore or switch to another application`;
+  let error;
+  let result;
+  while (result === void 0) {
     const selection = await ctx.requestUserInput({
-      prompt: "Ready to continue?",
+      prompt,
       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."
+      options,
+      error,
+      disabled,
+      helpText: hasIndices ? "Choose an existing index with data, or create a new index from sample data." : void 0
     });
     if (typeof selection !== "string") {
-      throw new Error("confirm-playbook received an unexpected result");
+      throw new Error(
+        "selectIndex received an unexpected non-text result"
+      );
+    }
+    if (selection === GO_BACK_OPTION) {
+      ctx.setUserInput("fetchedIndices", void 0);
+      return ctx.returnToStep("select-playbook");
     }
     if (selection === SELECT_APP_OPTION) {
       await ctx.changeApplication();
       continue;
     }
-    if (selection === GO_BACK_OPTION) {
-      return ctx.returnToStep("select-playbook");
+    if (selection === CREATE_SAMPLE_INDEX) {
+      result = {
+        indexName: "",
+        sampleIndex: true
+      };
+      break;
     }
+    const selectedIndex = indices.find(
+      (idx) => formatIndexOption(idx) === selection
+    );
+    if (!selectedIndex) {
+      error = "Invalid selection. Please try again.";
+      continue;
+    }
+    result = {
+      indexName: selectedIndex.name,
+      sampleIndex: false
+    };
+  }
+  return result;
+}
+
+// src/actions/playbookSteps/confirmIndex.ts
+import "zod";
+var confirmIndexSchema = playbookExecutionSchema.nullable();
+var CONTINUE_OPTION = "Looks good, continue";
+var GO_BACK_OPTION2 = "Go back";
+async function confirmIndexStep(ctx) {
+  const { sampleIndex } = ctx.getStepOutput("select-index");
+  if (!sampleIndex) {
+    return null;
+  }
+  const { slug } = ctx.getStepOutput("select-playbook");
+  const selection = await ctx.requestUserInput({
+    prompt: "Ready to create sample index?",
+    promptType: "multipleChoice",
+    options: [CONTINUE_OPTION, GO_BACK_OPTION2],
+    messages: [
+      `A new index called "algolia_playbooks_${slug}_sample_index" will be created with sample ${slug} data.`
+    ],
+    helpText: "Going back lets you choose a different index."
+  });
+  if (typeof selection !== "string") {
+    throw new Error("confirm-index received an unexpected result");
+  }
+  if (selection === GO_BACK_OPTION2) {
+    return ctx.returnToStep("select-index");
+  }
+  ctx.notify({
+    messages: ["Creating sample index and playbook execution\u2026"]
+  });
+  const app = await requireApplication();
+  const playbookSlug = ctx.getUserInput("playbookSlug");
+  if (!playbookSlug) {
+    throw new Error("No playbook slug found in context");
+  }
+  try {
+    const execution = await createSampleIndex(app.id, playbookSlug);
+    ctx.setUserInput("fetchedIndices", void 0);
+    ctx.clearNotices();
+    ctx.notify({
+      messages: [
+        `Sample index "${execution.source_index_name}" created successfully!`
+      ]
+    });
+    return execution;
+  } catch (error) {
+    ctx.clearNotices();
+    ctx.notify({
+      messages: ["Failed to create sample index. Please try again."]
+    });
+    throw error;
+  }
+}
+
+// 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
@@ -6567,11 +6956,25 @@ var playbookWorkflow = {
       run: (ctx) => selectPlaybookStep(ctx, getPlaybookSlugArg())
     }),
     defineStep({
-      id: "confirm-playbook",
-      title: "Confirm selections",
-      outputSchema: confirmPlaybookSchema,
+      id: "select-index",
+      title: "Select index",
+      outputSchema: selectIndexSchema,
+      tips: ["apps-and-indices", "records-are-json", "speed"],
+      run: (ctx) => selectIndexStep2(ctx)
+    }),
+    defineStep({
+      id: "confirm-index",
+      title: "Confirm sample index creation",
+      outputSchema: confirmIndexSchema,
       visible: false,
-      run: (ctx) => confirmPlaybookStep(ctx)
+      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)
     })
   ]
 };
@@ -7467,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(
@@ -7652,6 +8055,27 @@ var search = {
 var selectPlaybook = {
   slug: "orders"
 };
+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.",
@@ -7673,7 +8097,9 @@ var SEEDS = {
   },
   playbook: {
     "select-playbook": selectPlaybook,
-    "confirm-playbook": void 0
+    "select-index": selectPlaybookIndex,
+    "confirm-index": null,
+    "data-assessment": dataAssessment
   }
 };
 var SEED_ALGOLIA_STATE = {
@@ -7687,7 +8113,9 @@ var SEED_USER_INPUTS = {
     implementation: "success"
   },
   playbook: {
-    playbookSlug: selectPlaybook.slug
+    playbookSlug: selectPlaybook.slug,
+    playbookIndexName: selectPlaybookIndex.indexName,
+    playbookSampleIndex: selectPlaybookIndex.sampleIndex
   }
 };
 function formatStepList(workflow, startIndex) {
@@ -7842,7 +8270,7 @@ function delay(ms) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.74.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.74.0",
+  "version": "0.76.0",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {