@algolia/wizard 0.70.0 → 0.72.0

package/dist/main.js

@@ -1969,7 +1969,7 @@ function identify(traits) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.70.0",
+  version: "0.72.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3440,6 +3440,12 @@ var DEFAULT_TOOL_LIMITS = {
   match: 100,
   shell: 50
 };
+var EMPTY_TOOL_COUNTS = {
+  list: 0,
+  search: 0,
+  read: 0,
+  shell: 0
+};
 var DEFAULT_SHELL_TIMEOUT_MS = 10 * 60 * 1e3;
 async function refuseByDefault() {
   return "reject";
@@ -3458,11 +3464,14 @@ function createToolContext(limits = DEFAULT_TOOL_LIMITS, cwd = process.cwd(), sh
     root: cwd,
     cwd,
     limits: { ...limits },
-    counts: { list: 0, search: 0, read: 0, shell: 0 },
+    counts: { ...EMPTY_TOOL_COUNTS },
     shell: shell2,
     reviewed: []
   };
 }
+function resetToolCounts(ctx) {
+  Object.assign(ctx.counts, EMPTY_TOOL_COUNTS);
+}
 
 // src/lib/tools/utils/runShell.ts
 var SIGKILL_DELAY_MS = 5e3;
@@ -4128,10 +4137,21 @@ var MISSING_REPORT_STATUS_ERROR_MESSAGE = "Agent finished without calling report
 var MISSING_REPORT_USER_MESSAGE = "This step ran into a problem finishing. Run the wizard again to retry it.";
 var REPORT_STATUS_RETRIES = 2;
 var ATTEMPT_NUMBER_OFFSET = 1;
+var INITIAL_ATTEMPT = 0;
 var PROVIDER_ERROR_USER_MESSAGE = "The AI service had trouble responding. Run the wizard again to retry this step.";
+var MissingReportError = class extends Error {
+  atStepLimit;
+  constructor(atStepLimit) {
+    super(MISSING_REPORT_STATUS_ERROR_MESSAGE);
+    this.atStepLimit = atStepLimit;
+  }
+};
+function isMissingReportRetry(kind) {
+  return kind === "missingReport" || kind === "missingReportAtStepLimit";
+}
 function retryKind(err) {
-  if (err instanceof Error && err.message === MISSING_REPORT_STATUS_ERROR_MESSAGE) {
-    return "missingReport";
+  if (err instanceof MissingReportError) {
+    return err.atStepLimit ? "missingReportAtStepLimit" : "missingReport";
   }
   if (NoOutputGeneratedError.isInstance(err)) return "transientProvider";
   if (APICallError.isInstance(err) && err.isRetryable) {
@@ -4140,37 +4160,42 @@ function retryKind(err) {
   return null;
 }
 function exhaustedError(kind, err) {
-  return kind === "missingReport" ? new Error(MISSING_REPORT_USER_MESSAGE) : new Error(PROVIDER_ERROR_USER_MESSAGE, { cause: err });
+  return isMissingReportRetry(kind) ? new Error(MISSING_REPORT_USER_MESSAGE) : new Error(PROVIDER_ERROR_USER_MESSAGE, { cause: err });
 }
 async function runAgent(req) {
-  for (let attempt = 0; attempt <= REPORT_STATUS_RETRIES; attempt++) {
+  let retryReason = null;
+  for (let attempt = INITIAL_ATTEMPT; attempt <= REPORT_STATUS_RETRIES; attempt++) {
     try {
-      return await runAgentAttempt(req, attempt);
+      return await runAgentAttempt(req, attempt, retryReason);
     } catch (err) {
       const kind = retryKind(err);
       if (!kind) throw err;
       if (attempt === REPORT_STATUS_RETRIES) throw exhaustedError(kind, err);
+      retryReason = kind === "transientProvider" && isMissingReportRetry(retryReason) ? retryReason : kind;
       logger.warn(
         { attempt: attempt + 1, err },
-        kind === "missingReport" ? "retrying runAgent after missing reportStatus" : "retrying runAgent after a transient provider error"
+        isMissingReportRetry(kind) ? "retrying runAgent after missing reportStatus" : "retrying runAgent after a transient provider error"
       );
     }
   }
   throw new Error("unreachable");
 }
-async function runAgentAttempt(req, attempt) {
+async function runAgentAttempt(req, attempt, retryReason) {
   const start = Date.now();
   const profileName = req.modelProfile ?? "implementation" /* implementation */;
   const profile = getModelProfile(profileName);
-  const modelOptions = providerOptionsForProfile(profileName);
+  const profileOptions = providerOptionsForProfile(profileName);
+  const forceReport = retryReason === "missingReport";
+  const modelOptions = forceReport ? { thinking: { type: "disabled" } } : profileOptions;
   logger.info(
     {
       startedAt: new Date(start).toISOString(),
       operation: req.operation,
       profile: profileName,
       model: profile.model,
-      effort: profile.effort,
-      thinking: profile.thinking
+      effort: forceReport ? void 0 : profile.effort,
+      thinking: forceReport ? "disabled" : profile.thinking,
+      retryReason
     },
     "runAgent started"
   );
@@ -4184,6 +4209,7 @@ async function runAgentAttempt(req, attempt) {
     fetch: proxyFetch
   });
   const toolContext = req.toolContext ?? createToolContext();
+  if (attempt > INITIAL_ATTEMPT) resetToolCounts(toolContext);
   const readTools = ["readFile", "searchFiles", "listFiles"];
   const hasReadTools = !req.tools || req.tools.some((t) => readTools.includes(t));
   const instructions = [
@@ -4195,8 +4221,14 @@ async function runAgentAttempt(req, attempt) {
     // Last so a retry does not bust the cached tools+system prefix from
     // the first attempt. Inspect-and-continue, not start over: implement
     // shares the worktree and toolContext across attempts.
-    ...attempt > 0 ? [
-      "This run is a retry after a previous attempt that did not finish. Files, shell commands, or ingestion may already have been applied in this workspace \u2014 inspect what is already there and continue from it rather than repeating that work."
+    ...retryReason === "missingReport" ? hasReadTools ? [
+      "The previous attempt ended without reportStatus. Do not repeat side effects. Use the available read tools to inspect existing work if needed, then call reportStatus."
+    ] : [
+      "The previous attempt ended without reportStatus. Do not repeat side effects. Call reportStatus now."
+    ] : retryReason === "missingReportAtStepLimit" ? [
+      "The previous attempt reached its step limit without reportStatus and may be incomplete. Inspect existing work, finish only the remaining work, avoid repeated side effects, and call reportStatus."
+    ] : attempt > 0 ? [
+      "This run is a retry after a transient AI service error. Files, shell commands, or ingestion may already have been applied in this workspace \u2014 inspect what is already there and continue from it rather than repeating that work."
     ] : []
   ];
   const agent = new ToolLoopAgent({
@@ -4304,7 +4336,8 @@ async function runAgentAttempt(req, attempt) {
       },
       "Agent finished without calling reportStatus"
     );
-    throw new Error(MISSING_REPORT_STATUS_ERROR_MESSAGE);
+    const incomplete = steps.length >= profile.maxSteps || lastStep?.finishReason !== "stop";
+    throw new MissingReportError(incomplete);
   }
   const result = report.output;
   if (result.status !== "success") {
@@ -5995,13 +6028,21 @@ import { z as z32 } from "zod";
 import "zod";
 var DASHBOARD_API_BASE_URL = `${PROXY_BASE_URL}/dashboard`;
 var DashboardApiError = class extends Error {
-  constructor(status, message) {
-    super(message);
+  constructor(status, body) {
+    super("Couldn't complete the request.");
     this.status = status;
+    this.body = body;
     this.name = "DashboardApiError";
   }
   status;
+  body;
+  errorBody() {
+    return isRecord(this.body) ? this.body : void 0;
+  }
 };
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
 async function dashboardRequest(path, schema, init) {
   const token = getAuthToken();
   if (!token) {
@@ -6016,17 +6057,24 @@ async function dashboardRequest(path, schema, init) {
     }
   });
   if (!res.ok) {
-    throw new DashboardApiError(
-      res.status,
-      `Dashboard API responded ${res.status} for ${path}`
-    );
+    throw await dashboardError(res);
   }
   const body = await res.json();
   return { status: res.status, data: schema.parse(body) };
 }
+async function dashboardError(res) {
+  try {
+    return new DashboardApiError(res.status, await res.json());
+  } catch {
+    return new DashboardApiError(res.status, void 0);
+  }
+}
 
 // src/lib/dashboardApi/schemas.ts
 import { z as z31 } from "zod";
+var messageResponseSchema = z31.object({
+  message: z31.string()
+});
 var playbookSchema = z31.object({
   slug: z31.string(),
   category: z31.string().optional(),
@@ -6034,6 +6082,57 @@ var playbookSchema = z31.object({
   description: z31.string().optional()
 });
 var playbooksListSchema = z31.array(playbookSchema);
+var playbookExecutionStepSchema = z31.enum([
+  "assessment",
+  "optimization",
+  "implement"
+]);
+var playbookExecutionStepStatusSchema = z31.enum([
+  "not_started",
+  "in_progress",
+  "done",
+  "error"
+]);
+var schemaComparisonEntrySchema = z31.object({
+  canonical_attr: z31.string(),
+  canonical_type: z31.array(z31.string()),
+  canonical_roles: z31.array(z31.string()),
+  canonical_required: z31.boolean(),
+  index_attr: z31.string().nullable(),
+  index_type: z31.array(z31.string()).nullable(),
+  index_required: z31.boolean().nullable(),
+  status: z31.string(),
+  mapping_confidence: z31.number()
+});
+var settingsRecommendationSchema = z31.record(
+  z31.string(),
+  z31.object({
+    current: z31.any(),
+    recommended: z31.any()
+  })
+);
+var assessmentResultSchema = z31.object({
+  ready: z31.boolean(),
+  schema_comparison: z31.array(schemaComparisonEntrySchema),
+  settings_recommendation: settingsRecommendationSchema
+});
+var playbookExecutionSchema = z31.object({
+  uuid: z31.string(),
+  playbook_slug: z31.string(),
+  application_id: z31.string(),
+  source_index_name: z31.string(),
+  current_step: playbookExecutionStepSchema,
+  step_status: playbookExecutionStepStatusSchema,
+  status_reason: z31.string().nullable(),
+  completed: z31.boolean(),
+  assessment_result: assessmentResultSchema.nullable(),
+  settings_snapshot: z31.json().nullable(),
+  created_at: z31.iso.datetime()
+});
+var playbookExecutionCreateResponseSchema = playbookExecutionSchema.extend({
+  resumed: z31.boolean(),
+  sample_data: z31.boolean()
+});
 
 // src/lib/dashboardApi/api.ts
 async function getPlaybooks() {
@@ -7556,7 +7655,7 @@ function delay(ms) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.70.0",
+  version: "0.72.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/package.json

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