@algolia/wizard 0.90.0 → 0.92.0

package/dist/main.js

@@ -1514,6 +1514,15 @@ function PromptInput() {
   return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
     inputReq.error && /* @__PURE__ */ jsx9(Text11, { color: COLORS.danger, children: inputReq.error }),
     inputReq.messages?.map((m, i) => /* @__PURE__ */ jsx9(Text11, { color: COLORS.muted, children: m }, `msg-${i}`)),
+    inputReq.suggestion && /* @__PURE__ */ jsxs10(Text11, { color: COLORS.muted, children: [
+      "Press",
+      " ",
+      /* @__PURE__ */ jsx9(Text11, { color: COLORS.accent, bold: true, children: "Enter" }),
+      " ",
+      "to use",
+      " ",
+      /* @__PURE__ */ jsx9(Text11, { color: COLORS.accent, bold: true, children: inputReq.suggestion })
+    ] }),
     /* @__PURE__ */ jsxs10(Box10, { children: [
       /* @__PURE__ */ jsxs10(Text11, { color: COLORS.primary, children: [
         inputReq.prompt,
@@ -1808,7 +1817,21 @@ function agentRunMetrics(event, values, tags) {
       value: Number(event.attempt > FIRST_ATTEMPT),
       type: COUNT_METRIC,
       tags: runTags
-    }
+    },
+    ...event.stepCount === void 0 ? [] : [
+      {
+        name: "wizard.agent.step_count",
+        value: event.stepCount,
+        type: GAUGE_METRIC,
+        tags: runTags
+      },
+      {
+        name: "wizard.agent.step_limit_hit",
+        value: Number(event.hitStepLimit === true),
+        type: COUNT_METRIC,
+        tags: runTags
+      }
+    ]
   ];
 }
 function trackAgentRun(event) {
@@ -1836,6 +1859,9 @@ function trackAgentRun(event) {
           thinking: profile.thinking,
           attempt: event.attempt,
           durationMs: event.durationMs,
+          stepCount: event.stepCount,
+          hitStepLimit: event.hitStepLimit,
+          finishReason: event.finishReason,
           workflow_id: AGENT_TELEMETRY_CONTEXT.workflowId,
           app_id: AGENT_TELEMETRY_CONTEXT.appId,
           ...values
@@ -2358,7 +2384,7 @@ async function ensureApplication(resumeAppId) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.90.0",
+  version: "0.92.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2831,6 +2857,9 @@ async function runWorkflow(workflow, startWorkflowAppId, options) {
   }
 }
 
+// src/actions/selectIndex.ts
+import { basename } from "node:path";
+
 // src/actions/listIndices.ts
 import { z as z5 } from "zod";
 var indicesListSchema = z5.object({
@@ -2865,11 +2894,27 @@ function indexNameError(name) {
     return "Index name cannot end with .txt, .bin, or .idx.";
   return void 0;
 }
+function slug(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function suggestIndexName(project, entity, taken) {
+  const base = ([slug(project), slug(entity ?? "")].filter(Boolean).join("_") || "records").slice(0, MAX_INDEX_NAME_LENGTH);
+  let name = base;
+  for (let n = 2; taken.includes(name); n++) {
+    const suffix = `_${n}`;
+    name = base.slice(0, MAX_INDEX_NAME_LENGTH - suffix.length) + suffix;
+  }
+  return name;
+}
 var selectIndexStep = async (ctx) => {
   await requireApplication(ctx.appId);
   const indices = await listIndices();
   const names = indices.map((i) => i.name);
   const hasIndices = names.length > 0;
+  const entity = ctx.getStepOutput(
+    "confirm-entities"
+  )?.confirmedEntities?.[0]?.name;
+  const suggested = suggestIndexName(basename(process.cwd()), entity, names);
   let error;
   let chosen;
   while (chosen === void 0) {
@@ -2886,6 +2931,7 @@ var selectIndexStep = async (ctx) => {
       messages: [
         "This app has no existing indices \u2014 enter a name to create one."
       ],
+      suggestion: suggested,
       error
     });
     if (typeof selection !== "string") {
@@ -2894,17 +2940,18 @@ var selectIndexStep = async (ctx) => {
     let candidate;
     let isNewName = true;
     if (!hasIndices) {
-      candidate = selection.trim();
+      candidate = selection.trim() || suggested;
     } else if (selection === CREATE_NEW_INDEX) {
       const name = await ctx.requestUserInput({
         prompt: "Name the new index:",
         promptType: "textInput",
-        options: []
+        options: [],
+        suggestion: suggested
       });
       if (typeof name !== "string") {
         throw new Error("selectIndex received an unexpected non-text result");
       }
-      candidate = name.trim();
+      candidate = name.trim() || suggested;
     } else {
       candidate = selection;
       isNewName = false;
@@ -3140,14 +3187,14 @@ import z9 from "zod";
 import { readFile as readFile4 } from "node:fs/promises";
 
 // src/lib/tools/env.ts
-import { basename } from "node:path";
+import { basename as basename2 } from "node:path";
 function isEnvFile(filePath) {
-  const name = basename(filePath);
+  const name = basename2(filePath);
   return name === ".env" || name.startsWith(".env.");
 }
 function isSecretEnvFile(filePath) {
   if (!isEnvFile(filePath)) return false;
-  const name = basename(filePath);
+  const name = basename2(filePath);
   return !/\.(example|sample|template)$/.test(name);
 }
 function secretEnvWriteRefusal(filePath) {
@@ -3782,7 +3829,7 @@ import { execFile as execFile2 } from "node:child_process";
 import { tool as tool8 } from "ai";
 import z15 from "zod";
 import { lstat as lstat3, readdir as readdir2, readFile as readFile8, realpath, stat as stat2 } from "node:fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute2, join as join8, relative as relative4, sep as sep2 } from "node:path";
+import { basename as basename3, isAbsolute as isAbsolute2, join as join8, relative as relative4, sep as sep2 } from "node:path";
 import { performance } from "node:perf_hooks";
 import { Worker } from "node:worker_threads";
 var MAX_GIT_OUTPUT_BYTES = 32e6;
@@ -4125,7 +4172,7 @@ async function safeSearchPath(rootPath, file) {
 }
 async function searchableFiles(root, target) {
   try {
-    if (SKIP_FILES.has(basename2(target)) && (await lstat3(target)).isFile()) {
+    if (SKIP_FILES.has(basename3(target)) && (await lstat3(target)).isFile()) {
       return [target];
     }
     const gitRoot = await gitRootForTarget(root, target);
@@ -4304,7 +4351,7 @@ import { tool as tool9 } from "ai";
 import z16 from "zod";
 import { createHash as createHash2 } from "node:crypto";
 import { readFile as readFile9, stat as stat3 } from "node:fs/promises";
-import { basename as basename3, relative as relative5, resolve as resolve3 } from "node:path";
+import { basename as basename4, relative as relative5, resolve as resolve3 } from "node:path";
 
 // src/lib/tools/utils/prompt.ts
 var chain = Promise.resolve();
@@ -4402,7 +4449,7 @@ function commandDiffersFromReviewedScript(ctx, command, cwd) {
   if (approval.command === command && approval.cwd === cwd) return false;
   if (approval.command === command) return true;
   const scriptReferences = [
-    basename3(approval.filePath),
+    basename4(approval.filePath),
     relative5(ctx.root, approval.filePath),
     ".algolia-wizard"
   ];
@@ -5123,8 +5170,8 @@ function generateRecordTool(ctx, createModel = defaultCreateModel2) {
           ...record,
           objectID: nanoid2()
         }));
-        const slug = entityName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-        const relPath = `${DATA_DIR}/${slug}.json`;
+        const slug2 = entityName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+        const relPath = `${DATA_DIR}/${slug2}.json`;
         const resolved2 = resolveInRoot(ctx, relPath);
         if (resolved2.ok === false) return resolved2.error;
         const writeError = await safeWriteFile(
@@ -5305,6 +5352,7 @@ async function runAgentAttempt(req, attempt, retryReason) {
   const profileName = req.modelProfile ?? "implementation" /* implementation */;
   const profile = getModelProfile(profileName);
   const profileOptions = providerOptionsForProfile(profileName);
+  const maxSteps = req.maxSteps ?? profile.maxSteps;
   const forceReport = retryReason === "missingReport";
   const modelOptions = forceReport ? { thinking: { type: "disabled" } } : profileOptions;
   logger.info(
@@ -5385,11 +5433,11 @@ async function runAgentAttempt(req, attempt, retryReason) {
     toolChoice: "required",
     stopWhen: [
       hasToolCall("reportStatus"),
-      stepCountIs(profile.maxSteps)
+      stepCountIs(maxSteps)
     ],
     prepareStep: ({ stepNumber, messages }) => ({
       messages: withCachedHistory(messages),
-      ...stepNumber >= profile.maxSteps - 1 && {
+      ...stepNumber >= maxSteps - 1 && {
         activeTools: ["reportStatus"]
       }
     }),
@@ -5429,12 +5477,20 @@ async function runAgentAttempt(req, attempt, retryReason) {
   }
   const end = Date.now();
   const usage = await stream.totalUsage;
+  const steps = await stream.steps;
+  const stepCount = steps.length;
+  const hitStepLimit = stepCount >= maxSteps;
+  const lastStep = steps[steps.length - 1];
+  const finishReason = lastStep?.finishReason;
   trackAgentRun({
     operation: req.operation,
     profile: profileName,
     attempt: attempt + ATTEMPT_NUMBER_OFFSET,
     durationMs: end - start,
-    usage
+    usage,
+    stepCount,
+    hitStepLimit,
+    finishReason
   });
   logger.info(
     {
@@ -5443,7 +5499,11 @@ async function runAgentAttempt(req, attempt, retryReason) {
       operation: req.operation,
       profile: profileName,
       model: profile.model,
-      usage
+      usage,
+      stepCount,
+      maxSteps,
+      hitStepLimit,
+      finishReason
     },
     "runAgent finished"
   );
@@ -5458,27 +5518,24 @@ async function runAgentAttempt(req, attempt, retryReason) {
   const toolResults = await stream.toolResults;
   const report = [...toolResults].reverse().find((r) => r.toolName === "reportStatus");
   if (!report) {
-    const steps = await stream.steps;
-    const lastStep = steps[steps.length - 1];
     logger.error(
       {
-        finishReason: lastStep?.finishReason,
+        finishReason,
         rawFinishReason: lastStep?.rawFinishReason,
-        stepCount: steps.length,
+        stepCount,
         lastStepToolCalls: lastStep?.toolCalls?.map((c) => c.toolName)
       },
       "Agent finished without calling reportStatus"
     );
-    const incomplete = steps.length >= profile.maxSteps || lastStep?.finishReason !== "stop";
+    const incomplete = hitStepLimit || finishReason !== "stop";
     throw new MissingReportError(incomplete);
   }
   const result = report.output;
   if (result.status !== "success") {
-    const steps = await stream.steps;
     logger.warn(
       {
         reason: result.reason,
-        stepCount: steps.length,
+        stepCount,
         recentSteps: steps.slice(-RECENT_STEPS_LOGGED).map((s) => ({
           text: s.text?.slice(0, LOGGED_CHARS),
           toolCalls: s.toolCalls?.map((c) => c.toolName),
@@ -6077,7 +6134,7 @@ import {
 // src/lib/git.ts
 import { execFile as execFile3 } from "node:child_process";
 import { copyFile, mkdir as mkdir4, stat as stat4 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname3, isAbsolute as isAbsolute3, join as join9, resolve as resolve4 } from "node:path";
+import { basename as basename5, dirname as dirname3, isAbsolute as isAbsolute3, join as join9, resolve as resolve4 } from "node:path";
 var MAX_BUFFER = 32 * 1024 * 1024;
 function git(args) {
   return new Promise((resolve6, reject) => {
@@ -6114,7 +6171,7 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
   } catch {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
-  const relPath = join9(ingestDir, basename4(source));
+  const relPath = join9(ingestDir, basename5(source));
   const dest = join9(repoRoot, relPath);
   if (resolve4(source) === resolve4(dest)) {
     return { ok: true, relPath };
@@ -6255,6 +6312,7 @@ var validationOutputSchema = z29.object({
   unrelatedFailure: z29.string().optional()
 });
 var MAX_IMPLEMENT_VALIDATION_ATTEMPTS = 3;
+var INGESTION_MAX_STEPS = 96;
 var FIRST_IMPLEMENTATION_ATTEMPT = 1;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
 var INGEST_DIR = ".algolia-wizard";
@@ -6640,10 +6698,15 @@ function ingestOutcome(executions, repoRoot, ingestCommand) {
   const succeeded = newestFirst.filter(
     (e) => e.approved && e.exitCode === 0 && !e.timedOut
   );
+  const run2 = succeeded.find(matchesReportedCommand) ?? succeeded.find((e) => withCount.includes(e));
+  const runs = executions.filter(
+    (e) => e.approved && matchesReportedCommand(e)
+  ).length;
   return {
-    run: succeeded.find(matchesReportedCommand) ?? succeeded.find((e) => withCount.includes(e)),
+    run: run2,
     attempt: ingestCommand ? newestFirst.find(matchesReportedCommand) : void 0,
-    recordCount: parseIngestRecordCount(withCount[0]?.output ?? "")
+    recordCount: parseIngestRecordCount(withCount[0]?.output ?? ""),
+    attempts: run2 && !matchesReportedCommand(run2) ? runs + 1 : runs
   };
 }
 var INGEST_OUTPUT_TAIL_CHARS = 400;
@@ -6685,8 +6748,8 @@ async function firstRecordIn(filePath) {
 async function ingestedRecordSample(repoRoot, entityName, uploadFilePath) {
   const candidates = [];
   if (entityName) {
-    const slug = entityName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-    candidates.push(join11(repoRoot, INGEST_DIR, "data", `${slug}.json`));
+    const slug2 = entityName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    candidates.push(join11(repoRoot, INGEST_DIR, "data", `${slug2}.json`));
   }
   if (uploadFilePath?.toLowerCase().endsWith(".json")) {
     candidates.push(join11(repoRoot, uploadFilePath));
@@ -7018,6 +7081,9 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
         tools: toolsForUseCase(currentUseCase, input.ingestionSource),
         outputSchema: implementationOutputSchema,
         modelProfile: isRetry ? "implementationRetry" /* implementationRetry */ : "implementation" /* implementation */,
+        ...currentUseCase === "ingestion" && {
+          maxSteps: INGESTION_MAX_STEPS
+        },
         toolContext
       });
     } catch (err) {
@@ -7151,7 +7217,8 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     const {
       run: ingestRun,
       attempt: ingestAttempt,
-      recordCount
+      recordCount,
+      attempts: ingestRunAttempts
     } = outcome;
     let ingestCwd = ".";
     if (ingestAttempt) {
@@ -7184,7 +7251,8 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
           record_count: ingestRecordCount,
           duration_ms: ingestDurationMs ?? 0,
           index_name: targetIndex,
-          record_schema: recordSchema(sample, confirmed2?.[0]?.attributes ?? [])
+          record_schema: recordSchema(sample, confirmed2?.[0]?.attributes ?? []),
+          attempts: ingestRunAttempts
         });
       } else {
         logger.warn(
@@ -7220,6 +7288,7 @@ ${detail}` : ""}`
         error_message: `ingestion did not complete: ${reason}`,
         error_type: "Ingest Records",
         product_area: "AI Wizard",
+        attempts: ingestRunAttempts,
         ...ingestAttempt?.exitCode != null ? { error_code: String(ingestAttempt.exitCode) } : {}
       });
     }
@@ -7623,9 +7692,9 @@ async function getPlaybooks() {
   );
   return data;
 }
-async function createPlaybookExecution(appId, slug, indexName, options) {
+async function createPlaybookExecution(appId, slug2, indexName, options) {
   const { data } = await dashboardRequest(
-    `/api/1/playbook-integrations/applications/${appId}/playbooks/${slug}/executions`,
+    `/api/1/playbook-integrations/applications/${appId}/playbooks/${slug2}/executions`,
     playbookExecutionCreateResponseSchema,
     {
       method: "POST",
@@ -7666,9 +7735,9 @@ async function assessPlaybookExecution(uuid) {
 var selectPlaybookSchema = z33.object({
   slug: z33.string()
 });
-function persistSlug(ctx, slug) {
-  ctx.setUserInput("playbookSlug", slug);
-  return { slug };
+function persistSlug(ctx, slug2) {
+  ctx.setUserInput("playbookSlug", slug2);
+  return { slug: slug2 };
 }
 async function selectPlaybookStep(ctx, requestedSlug) {
   const playbooks = await getPlaybooks();
@@ -7799,13 +7868,13 @@ async function confirmIndexStep(ctx) {
   if (!sampleIndex) {
     return null;
   }
-  const { slug } = ctx.getStepOutput("select-playbook");
+  const { slug: slug2 } = 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.`
+      `A new index called "algolia_playbooks_${slug2}_sample_index" will be created with sample ${slug2} data.`
     ],
     helpText: "Going back lets you choose a different index."
   });
@@ -7957,13 +8026,13 @@ var POLL_NOTICES = [
   { message: "detecting required fields\u2026" }
 ];
 async function dataAssessmentStep(ctx) {
-  const { slug } = ctx.getStepOutput("select-playbook");
+  const { slug: slug2 } = 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);
+    const execution = await resolveExecution(ctx, appId, slug2, indexName);
     const assessed = await runAssessment(ctx, execution, indexName);
     ctx.clearNotices();
     await promptReady(ctx, assessed);
@@ -8068,24 +8137,24 @@ function unexpectedAssessmentStatus(status) {
     `data-assessment received an unexpected assessment status: ${status}`
   );
 }
-async function resolveExecution(ctx, appId, slug, indexName) {
-  const created = await createWithRecovery(ctx, appId, slug, indexName);
+async function resolveExecution(ctx, appId, slug2, indexName) {
+  const created = await createWithRecovery(ctx, appId, slug2, indexName);
   if (!created.resumed) return created;
   const choice = await promptResumeExecution(ctx, indexName);
   if (choice === CONTINUE_EXECUTION_OPTION) return created;
   if (choice === RESTART_OPTION) {
-    return createWithRecovery(ctx, appId, slug, indexName, { forceNew: true });
+    return createWithRecovery(ctx, appId, slug2, 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) {
+async function createWithRecovery(ctx, appId, slug2, indexName, options) {
   return retryOnDashboardError(
     () => {
       showNotice(ctx, CREATING_EXECUTION_NOTICE);
-      return createPlaybookExecution(appId, slug, indexName, options);
+      return createPlaybookExecution(appId, slug2, indexName, options);
     },
     onRequestFailure(ctx, indexName)
   );
@@ -9764,7 +9833,7 @@ async function resetProjectState() {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.90.0",
+  version: "0.92.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/package.json

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