@algolia/wizard 0.92.0 → 0.94.0

package/dist/main.js

@@ -2384,7 +2384,7 @@ async function ensureApplication(resumeAppId) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.92.0",
+  version: "0.94.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -5282,13 +5282,37 @@ function isProxyInactivityRejection(err) {
   const cause = RetryError.isInstance(err) ? err.lastError : err;
   return APICallError.isInstance(cause) && cause.statusCode === 401 && cause.responseBody === PROXY_REJECTION_BODY && cause.responseHeaders?.[PROXY_AUTH_REJECTED_HEADER2] === void 0;
 }
+var INCOMPLETE_CAUSES = {
+  stepLimit: {
+    kind: "missingReportAtStepLimit",
+    reason: "reached its step limit"
+  },
+  truncated: {
+    kind: "missingReportTruncated",
+    reason: "was cut off by the output token limit"
+  },
+  stopped: {
+    kind: "missingReportStopped",
+    reason: "stopped before it finished"
+  }
+};
+var INCOMPLETE_CAUSE_ENTRIES = Object.values(INCOMPLETE_CAUSES);
+function incompleteReasonOf(kind) {
+  return INCOMPLETE_CAUSE_ENTRIES.find((entry) => entry.kind === kind)?.reason;
+}
 var MissingReportError = class extends Error {
-  atStepLimit;
-  constructor(atStepLimit) {
+  incompleteCause;
+  constructor(incompleteCause) {
     super(MISSING_REPORT_STATUS_ERROR_MESSAGE);
-    this.atStepLimit = atStepLimit;
+    this.incompleteCause = incompleteCause;
   }
 };
+function incompleteCauseOf(stepCount, maxSteps, finishReason) {
+  if (stepCount >= maxSteps) return "stepLimit";
+  if (finishReason === "length") return "truncated";
+  if (finishReason !== "stop") return "stopped";
+  return null;
+}
 var AgentReportedFailureError = class extends Error {
   reason;
   constructor(reason) {
@@ -5314,11 +5338,11 @@ function withCachedHistory(messages) {
   ];
 }
 function isMissingReportRetry(kind) {
-  return kind === "missingReport" || kind === "missingReportAtStepLimit";
+  return kind === "missingReport" || incompleteReasonOf(kind) !== void 0;
 }
 function retryKind(err) {
   if (err instanceof MissingReportError) {
-    return err.atStepLimit ? "missingReportAtStepLimit" : "missingReport";
+    return err.incompleteCause ? INCOMPLETE_CAUSES[err.incompleteCause].kind : "missingReport";
   }
   if (NoOutputGeneratedError.isInstance(err)) return "transientProvider";
   if (APICallError.isInstance(err) && err.isRetryable) {
@@ -5354,6 +5378,7 @@ async function runAgentAttempt(req, attempt, retryReason) {
   const profileOptions = providerOptionsForProfile(profileName);
   const maxSteps = req.maxSteps ?? profile.maxSteps;
   const forceReport = retryReason === "missingReport";
+  const incompleteReason = incompleteReasonOf(retryReason);
   const modelOptions = forceReport ? { thinking: { type: "disabled" } } : profileOptions;
   logger.info(
     {
@@ -5394,8 +5419,8 @@ async function runAgentAttempt(req, attempt, retryReason) {
       "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."
+    ] : incompleteReason ? [
+      `The previous attempt ${incompleteReason} 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."
     ] : []
@@ -5527,8 +5552,9 @@ async function runAgentAttempt(req, attempt, retryReason) {
       },
       "Agent finished without calling reportStatus"
     );
-    const incomplete = hitStepLimit || finishReason !== "stop";
-    throw new MissingReportError(incomplete);
+    throw new MissingReportError(
+      incompleteCauseOf(stepCount, maxSteps, finishReason)
+    );
   }
   const result = report.output;
   if (result.status !== "success") {
@@ -6381,7 +6407,8 @@ function sourceSpecificInstructions(input) {
       "Read each record from its real local source at the confirmed entity paths.",
       "Never fabricate, hardcode, or use placeholder records.",
       "Add env vars for any local source access (DB URL, API base, file paths) that is not a fixed repo path.",
-      "To read a database, use the database client or ORM that the project already declares in its manifest. Never install a database driver or ORM. If the project declares none, report that limitation instead of adding one."
+      "To read a database, use the database client or ORM that the project already declares in its manifest. Never install a database driver or ORM. If the project declares none, report that limitation instead of adding one.",
+      "Prefer a server-side credential (a service-role, secret, or admin key, or a database password) over a client-side or public key (for example an anon or publishable key, or any key the project exposes to its frontend) when the source has both: public keys are subject to the source's access rules and can return zero records without an error. Use a public key only when the source offers nothing else. Check the connection to the source before you check for its credential, and make that connection check work without the credential, so an unreachable service is never reported as a missing credential. If the credential the script needs is not in the environment, the script must print an error that names the variable and where the developer finds it, then exit with an error. Never install a client library or driver to work around a missing credential."
     ],
     fileUpload: [
       `Records come from the developer's file, already copied into the project at "${input.uploadFilePath}". Read and parse that exact file.`,
@@ -6437,7 +6464,7 @@ function ingestionInstructions(input) {
       ] : [],
       `When the script is finished, decide the exact command and cwd you will use to run it. Make sure that the script path in the command resolves from that cwd to the filePath. Then call reviewScript with that filePath, command, cwd, the exact selected entityName, and usesGeneratedRecords set to ${input.ingestionSource === "generated"}. Wait for the developer to review it because running it writes records to a live index. Do not run it before that call returns. If you change the command or cwd after a failed run, call reviewScript again before runShell.`,
       'Then, without changing directories, run the script yourself via runShell using the exact same command and cwd. Report the exact command you ran as "ingestCommand", with no cwd note or other text, so the developer can re-run it. Its explanation must say that running it writes records to Algolia.',
-      "When the script reads from a database or another service, find how the project connects to it locally (env files, README, socket or TCP settings). If that connection needs a local service, such as a database proxy (for example cloud-sql-proxy) or a tunnel, make the script check the connection before it reads. If the check fails, the script must print an error that names the service, then print exactly one last line to stdout in the form `ALGOLIA_WIZARD_START_HINT=<command>`, where <command> is the command from the project docs that starts the service, and exit with an error. Omit that line when the project docs name no start command.",
+      "When the script reads from a database or another service, find how the project connects to it locally (env files, README, the service's own config file for its host and port, socket or TCP settings). Use the host and port that config sets, not a default. If that connection needs a local service, such as a database proxy (for example cloud-sql-proxy), a tunnel, or a service the project starts with its own CLI or scripts (not necessarily Docker Compose), make the script check the connection before it reads. If the check fails, the script must print an error that names the service, then print exactly one last line to stdout in the form `ALGOLIA_WIZARD_START_HINT=<command>`, where <command> is the command from the project docs or scripts (README, package.json scripts, Makefile) that starts the service, and exit with an error. Omit that line when neither names a start command.",
       "Make sure that the start command and the script connect to the same address (the same socket path, or the same host and port). If the project env points at an address that only a deployed environment has, such as a /cloudsql socket, make the script connect to the address of the start command. Set that address in the script before it loads the project database module. Do not edit project env or config files for this.",
       "When the script uses the project database client or ORM, load that client's env file (the project .env the client already reads) so credentials such as DB user, password, and database name are present. Load the wizard Algolia .env first, then the project .env, so Algolia keys win under dotenv versions that ignore `override`. Do not rely on `override: true`.",
       "If external data access fails, do not run authentication commands, change accounts or machine configuration, or start proxies, containers, or services.",
@@ -6675,6 +6702,12 @@ function parseIngestRecordCount(output) {
   const count = Number(match[1]);
   return Number.isFinite(count) ? count : void 0;
 }
+function indexedNothing(execution) {
+  return parseIngestRecordCount(execution.output ?? "") === 0;
+}
+function ranButIndexedNothing(execution) {
+  return execution.approved && execution.exitCode === 0 && !execution.timedOut && indexedNothing(execution);
+}
 var START_HINT_LINE = /^ALGOLIA_WIZARD_START_HINT=(.*)$/gm;
 function parseStartHint(output) {
   const matches = [...(output ?? "").matchAll(START_HINT_LINE)];
@@ -6696,7 +6729,7 @@ function ingestOutcome(executions, repoRoot, ingestCommand) {
     (e) => parseIngestRecordCount(e.output ?? "") != null
   );
   const succeeded = newestFirst.filter(
-    (e) => e.approved && e.exitCode === 0 && !e.timedOut
+    (e) => e.approved && e.exitCode === 0 && !e.timedOut && !indexedNothing(e)
   );
   const run2 = succeeded.find(matchesReportedCommand) ?? succeeded.find((e) => withCount.includes(e));
   const runs = executions.filter(
@@ -6705,7 +6738,9 @@ function ingestOutcome(executions, repoRoot, ingestCommand) {
   return {
     run: run2,
     attempt: ingestCommand ? newestFirst.find(matchesReportedCommand) : void 0,
-    recordCount: parseIngestRecordCount(withCount[0]?.output ?? ""),
+    recordCount: parseIngestRecordCount(
+      withCount.find((e) => !indexedNothing(e))?.output ?? ""
+    ),
     attempts: run2 && !matchesReportedCommand(run2) ? runs + 1 : runs
   };
 }
@@ -6785,9 +6820,13 @@ function noRunReason({
   }
   return "no successful run was recorded";
 }
+var EMPTY_INGEST_DETAIL = "The script read no records. A client-side or public key can return no rows because of access rules, so check that it reads with a server-side credential and that the data source has data.";
 function ingestFailure(attempt, missingRunReason = "no successful run was recorded") {
   if (!attempt) return { reason: missingRunReason };
   if (!attempt.approved) return { reason: "you declined to run it" };
+  if (ranButIndexedNothing(attempt)) {
+    return { reason: "it ran but indexed 0 records", detail: EMPTY_INGEST_DETAIL };
+  }
   const detail = errorLine(attempt.output);
   if (attempt.timedOut) {
     const seconds = Math.round((attempt.durationMs ?? 0) / 1e3);
@@ -6828,8 +6867,8 @@ function briefSummary(summary) {
   if (!firstLine) return "no summary given";
   return firstLine.length > ERROR_SUMMARY_MAX_CHARS ? `${firstLine.slice(0, ERROR_SUMMARY_MAX_CHARS - 1)}\u2026` : firstLine;
 }
-function ingestionRetryInstruction(reason) {
-  return `The previous ingestion attempt ended with no successful run: ${reason}. Look in "${INGEST_DIR}/" for a script from that attempt and finish or fix it instead of starting over. Then call reviewScript and run the script as described above.`;
+function ingestionRetryInstruction(reason, detail) {
+  return `The previous ingestion attempt ended with no successful run: ${reason}.${detail ? ` ${detail}` : ""} Look in "${INGEST_DIR}/" for a script from that attempt and finish or fix it instead of starting over. Then call reviewScript and run the script as described above.`;
 }
 function validationRetryInstructions(validation) {
   return [
@@ -7166,19 +7205,22 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     await runIngestionAgent();
     let outcome = ingestOutcome(executions, repoRoot, ingestCommand);
     let failureAcknowledged = false;
-    while (!outcome.run && !outcome.attempt) {
-      const reason = await currentNoRunReason();
+    while (!outcome.run && (!outcome.attempt || ranButIndexedNothing(outcome.attempt))) {
+      const { reason, detail } = outcome.attempt ? ingestFailure(outcome.attempt) : { reason: await currentNoRunReason(), detail: void 0 };
       const choice = await ctx.requestUserInput({
         prompt: INGEST_AGENT_RETRY_PROMPT,
         promptType: "multipleChoice",
         options: [INGEST_RETRY.retry, INGEST_RETRY.skip],
-        messages: [`\u26A0\uFE0F Records were not indexed \u2014 ${reason}.`]
+        messages: [
+          `\u26A0\uFE0F Records were not indexed \u2014 ${reason}.`,
+          ...detail ? [detail] : []
+        ]
       });
       if (choice !== INGEST_RETRY.retry) {
         failureAcknowledged = true;
         break;
       }
-      await runIngestionAgent([ingestionRetryInstruction(reason)]);
+      await runIngestionAgent([ingestionRetryInstruction(reason, detail)]);
       outcome = ingestOutcome(executions, repoRoot, ingestCommand);
     }
     while (!failureAcknowledged && !outcome.run && outcome.attempt?.approved) {
@@ -9833,7 +9875,7 @@ async function resetProjectState() {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.92.0",
+  version: "0.94.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/package.json

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