@algolia/wizard 0.45.0 → 0.46.0-rc.136.345

package/dist/main.js

@@ -239,6 +239,9 @@ function describeInputValue(value) {
 }
 var NOTICE_INTERVAL_MS = 2e3;
 var CLI_OUTPUT_LIMIT = 200;
+function commandApprovalKey(command, cwd) {
+  return `${cwd}\0${command}`;
+}
 var useWizard = create((set, get) => ({
   phase: "idle",
   homeScreen: "home",
@@ -352,10 +355,17 @@ var useWizard = create((set, get) => ({
   setTargetIndex: (index) => set({ targetIndex: index }),
   recordWrittenFile: (path) => set((s) => ({ writtenFiles: [...s.writtenFiles, path] })),
   clearWrittenFiles: () => set({ writtenFiles: [] }),
-  isCommandApproved: (command, cwd) => get().approvedCommands.has(`${cwd}\0${command}`),
+  isCommandApproved: (command, cwd) => get().approvedCommands.has(commandApprovalKey(command, cwd)),
   approveCommand: (command, cwd) => set((s) => ({
-    approvedCommands: new Set(s.approvedCommands).add(`${cwd}\0${command}`)
+    approvedCommands: new Set(s.approvedCommands).add(
+      commandApprovalKey(command, cwd)
+    )
   })),
+  revokeCommand: (command, cwd) => set((s) => {
+    const approvedCommands = new Set(s.approvedCommands);
+    approvedCommands.delete(commandApprovalKey(command, cwd));
+    return { approvedCommands };
+  }),
   logStart: (kind, name, input) => {
     const id = nanoid();
     set((s) => ({
@@ -731,9 +741,11 @@ function DecisionSelect({
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function CommandApproval({
   command,
+  messages,
   onDecide
 }) {
   return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", gap: 1, children: [
+    messages?.map((message, index) => /* @__PURE__ */ jsx5(Text6, { color: COLORS.muted, children: message }, `msg-${index}`)),
     /* @__PURE__ */ jsx5(Text6, { color: COLORS.primary, bold: true, children: "Run this command?" }),
     /* @__PURE__ */ jsxs5(
       Box6,
@@ -1074,7 +1086,6 @@ function PromptInput() {
     return /* @__PURE__ */ jsx7(Box9, { flexGrow: 1, children: /* @__PURE__ */ jsx7(
       SelectPrompt,
       {
-        question: inputReq.prompt,
         messages: inputReq.messages,
         options: ["Continue"],
         onSelect: submitInput
@@ -1093,7 +1104,14 @@ function PromptInput() {
     );
   }
   if (inputReq.promptType === "commandApproval" && inputReq.command) {
-    return /* @__PURE__ */ jsx7(CommandApproval, { command: inputReq.command, onDecide: submitInput });
+    return /* @__PURE__ */ jsx7(
+      CommandApproval,
+      {
+        command: inputReq.command,
+        messages: inputReq.messages,
+        onDecide: submitInput
+      }
+    );
   }
   if (inputReq.promptType === "acceptReject") {
     const labels = inputReq.options?.length ? inputReq.options : ACCEPT_REJECT_OPTIONS;
@@ -2556,9 +2574,16 @@ function searchFilesTool(ctx) {
 }
 
 // src/lib/tools/runShell.ts
-import { tool as tool8, generateText, Output } from "ai";
+import { tool as tool9, generateText, Output } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
+import z16 from "zod";
+import { relative as relative5 } from "node:path";
+
+// src/lib/tools/reviewScript.ts
+import { tool as tool8 } from "ai";
 import z15 from "zod";
+import { createHash } from "node:crypto";
+import { readFile as readFile7, stat as stat2 } from "node:fs/promises";
 import { relative as relative4 } from "node:path";
 
 // src/lib/tools/utils/prompt.ts
@@ -2570,6 +2595,116 @@ function serializePrompt(work) {
   return result;
 }
 
+// src/lib/tools/reviewScript.ts
+var reviewedCommandApprovals = /* @__PURE__ */ new WeakMap();
+async function fileDigest(filePath) {
+  const content = await readFile7(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+function grantReviewedCommandApproval(ctx, approval) {
+  reviewedCommandApprovals.set(ctx, approval);
+}
+function getReviewedCommandApproval(ctx, command, cwd) {
+  const approval = reviewedCommandApprovals.get(ctx);
+  if (approval?.command !== command || approval.cwd !== cwd) return void 0;
+  return approval;
+}
+function clearReviewedCommandApproval(ctx) {
+  reviewedCommandApprovals.delete(ctx);
+}
+function revokeCommandApprovals(ctx, command, cwd) {
+  clearReviewedCommandApproval(ctx);
+  useWizard.getState().revokeCommand(command, cwd);
+}
+async function reviewedCommandApprovalIsCurrent(approval) {
+  const currentDigest = await fileDigest(approval.filePath).catch(() => null);
+  return currentDigest === approval.digest;
+}
+function reviewScriptTool(ctx) {
+  return tool8({
+    description: "Call this as soon as the ingestion script is finished and before you run it. It summarizes the records that will be written, then asks the user to review the script and approve the exact command that will run it, so a matching runShell call needs no second approval.",
+    inputSchema: z15.object({
+      filePath: z15.string().describe(
+        "Path to the script to review, relative to the project root."
+      ),
+      command: z15.string().min(1).describe("The exact command that runShell will use to run the script."),
+      cwd: z15.string().describe(
+        "The exact working directory that runShell will use, relative to the current tool working directory."
+      ),
+      entityName: z15.string().trim().min(1).max(100).regex(/^[^\r\n]+$/).describe("The exact entity name selected by the user."),
+      usesGeneratedRecords: z15.boolean().describe(
+        "Whether the script reads generated sample records instead of the selected real data source."
+      )
+    }),
+    execute: async ({
+      filePath,
+      command,
+      cwd,
+      entityName,
+      usesGeneratedRecords
+    }) => {
+      logger.info(
+        { filePath, command, cwd, entityName, usesGeneratedRecords },
+        "called reviewScript tool"
+      );
+      const resolved2 = resolveInRoot(ctx, filePath);
+      if (resolved2.ok === false) return resolved2.error;
+      const resolvedCwd = resolveInRoot(ctx, cwd);
+      if (resolvedCwd.ok === false) return resolvedCwd.error;
+      const displayCwd = relative4(ctx.root, resolvedCwd.target) || ".";
+      const displayFilePath = relative4(ctx.root, resolved2.target);
+      const ingestionSummary = usesGeneratedRecords ? `This will push ${entityName} records from generated sample data to Algolia. You can replace the sample dataset with your real data source in ${displayFilePath}.` : `This will push ${entityName} records from your selected source to Algolia.`;
+      return serializePrompt(async () => {
+        revokeCommandApprovals(ctx, command, resolvedCwd.target);
+        const isFile = await stat2(resolved2.target).then(
+          (s) => s.isFile(),
+          () => false
+        );
+        if (!isFile) {
+          return `Refused: ${filePath} is not a file. Write the script first, then review the path you wrote.`;
+        }
+        const reviewedDigest = await fileDigest(resolved2.target).catch(
+          () => null
+        );
+        if (reviewedDigest === null) {
+          return `Refused: ${filePath} could not be read. Write the script first, then review it again.`;
+        }
+        const answer = await useWizard.getState().requestUserInput({
+          prompt: "Run this command?",
+          promptType: "commandApproval",
+          options: [],
+          messages: [
+            `We have created your ingestion script. Please review it at ${displayFilePath} before approving.`
+          ],
+          command: {
+            command,
+            cwd: displayCwd,
+            explanation: ingestionSummary
+          }
+        });
+        if (answer !== "approve") {
+          revokeCommandApprovals(ctx, command, resolvedCwd.target);
+          return "The user declined to run this ingestion script. Do not run it.";
+        }
+        const approvedDigest = await fileDigest(resolved2.target).catch(
+          () => null
+        );
+        if (approvedDigest !== reviewedDigest) {
+          return "The ingestion script changed while it was being reviewed. Call reviewScript again before running it.";
+        }
+        ctx.reviewed.push(resolved2.target);
+        grantReviewedCommandApproval(ctx, {
+          command,
+          cwd: resolvedCwd.target,
+          filePath: resolved2.target,
+          digest: reviewedDigest
+        });
+        return "The user reviewed the script and approved this exact command. Run it now with the same cwd.";
+      });
+    }
+  });
+}
+
 // src/lib/tools/utils/runShell.ts
 import { spawn as spawn2 } from "node:child_process";
 
@@ -2668,7 +2803,7 @@ function storeApproval(root) {
   return async (req) => {
     const store = useWizard.getState();
     if (store.isCommandApproved(req.command, req.cwd)) return "approve";
-    const rel = relative4(root, req.cwd);
+    const rel = relative5(root, req.cwd);
     const answer = await store.requestUserInput({
       prompt: "Run this command?",
       promptType: "commandApproval",
@@ -2821,9 +2956,9 @@ function fastPathSafety(command) {
   return void 0;
 }
 var CLASSIFIER_MODEL = "claude-haiku-4-5";
-var commandSafetySchema = z15.object({
-  safe: z15.boolean(),
-  reason: z15.string().describe("One short sentence explaining the verdict.")
+var commandSafetySchema = z16.object({
+  safe: z16.boolean(),
+  reason: z16.string().describe("One short sentence explaining the verdict.")
 });
 function defaultCreateModel() {
   const token = getAuthToken();
@@ -2883,12 +3018,15 @@ async function classifyCommandSafety(createModel, command, cwd, explanation, app
     return false;
   }
 }
-async function runAndRecord(ctx, command, cwd) {
-  useWizard.getState().pushNotice({ messages: [`Running: ${command}`] });
-  const env = await ctx.shell.env().catch((err) => {
+async function resolveShellEnv(ctx, command) {
+  return ctx.shell.env().catch((err) => {
     logger.warn({ err, command }, "runShell: could not resolve command env");
     return {};
   });
+}
+async function runAndRecord(ctx, command, cwd, resolvedEnv) {
+  useWizard.getState().pushNotice({ messages: [`Running: ${command}`] });
+  const env = resolvedEnv ?? await resolveShellEnv(ctx, command);
   const run2 = await (ctx.shell.run ?? runShell)(command, {
     cwd,
     env,
@@ -2919,6 +3057,16 @@ async function runAndRecord(ctx, command, cwd) {
     output: run2.output
   };
 }
+async function runReviewedCommand(ctx, command, cwd) {
+  const approval = getReviewedCommandApproval(ctx, command, cwd);
+  if (!approval) return void 0;
+  const env = await resolveShellEnv(ctx, command);
+  if (!await reviewedCommandApprovalIsCurrent(approval)) {
+    return `Refused: ${relative5(ctx.root, approval.filePath)} changed after review. Call reviewScript again before running it.`;
+  }
+  clearReviewedCommandApproval(ctx);
+  return runAndRecord(ctx, command, cwd, env);
+}
 async function approveAndRun(ctx, command, cwd, explanation) {
   const decision = await ctx.shell.approve({ command, cwd, explanation });
   if (decision === "reject") {
@@ -2929,16 +3077,16 @@ async function approveAndRun(ctx, command, cwd, explanation) {
   return runAndRecord(ctx, command, cwd);
 }
 function runShellTool(ctx, createModel = defaultCreateModel) {
-  return tool8({
+  return tool9({
     description: "Run a shell command in the project. Use this for anything the project needs done in its own ecosystem: installing dependencies, running a script you wrote, running the project's lint/typecheck/test commands. Do not use this to find or read files \u2014 use listFiles, searchFiles, and readFile instead of shell file-listing, reading, or search commands (ls/find/tree/cat/head/tail/grep/rg and similar). This tool refuses all of those outright: the dedicated tools enforce the project-root boundary and secret redaction that a raw shell read would bypass, and they won't count against this tool's command budget. The user approves any command that could change the project before it runs, so write a clear `explanation`. A command judged read-only (inspection, or running tests/typecheck/lint without an autofix flag, in any language) runs immediately without approval. If the user rejects a command, do not retry it \u2014 propose a different approach.",
-    inputSchema: z15.object({
-      command: z15.string().describe(
+    inputSchema: z16.object({
+      command: z16.string().describe(
         "The command to run, exactly as it would be typed in a shell. Pipes, && and redirects are allowed."
       ),
-      cwd: z15.string().optional().describe(
+      cwd: z16.string().optional().describe(
         "Directory to run in, relative to the project root. Defaults to the project root."
       ),
-      explanation: z15.string().describe(
+      explanation: z16.string().describe(
         "One short line telling the user what this command does and why, including any side effect (e.g. writes records to Algolia). This is what they approve against."
       )
     }),
@@ -2947,16 +3095,22 @@ function runShellTool(ctx, createModel = defaultCreateModel) {
         return `Refused: command limit (${ctx.limits.shell}) reached. Stop running commands and report what you have.`;
       }
       const resolved2 = resolveInRoot(ctx, cwd ?? ".");
-      if (!resolved2.ok) return resolved2.error;
+      if (resolved2.ok === false) return resolved2.error;
       if (isFileIOCommand(command)) {
         return "Refused: use listFiles or searchFiles to find files, and readFile to read one, instead of a shell file-listing, reading, or search command (ls/find/fd/tree/dir/locate/cat/head/tail/less/more/tac/nl/grep/egrep/fgrep/rg/ack/ag/xxd/hexdump/od/strings).";
       }
       logger.info({ command, cwd: resolved2.target }, "called runShell tool");
+      const reviewed = await serializePrompt(
+        () => runReviewedCommand(ctx, command, resolved2.target)
+      );
+      if (reviewed !== void 0) return reviewed;
       const fast = fastPathSafety(command);
       let isSafe = fast;
+      let usedStoredApproval = false;
       if (isSafe === void 0) {
         const store = useWizard.getState();
-        isSafe = store.isCommandApproved(command, resolved2.target);
+        usedStoredApproval = store.isCommandApproved(command, resolved2.target);
+        isSafe = usedStoredApproval;
         if (!isSafe) {
           isSafe = await classifyCommandSafety(
             createModel,
@@ -2967,54 +3121,18 @@ function runShellTool(ctx, createModel = defaultCreateModel) {
           );
         }
       }
-      if (isSafe) {
-        return serializePrompt(
-          () => runAndRecord(ctx, command, resolved2.target)
-        );
-      }
-      return serializePrompt(
-        () => approveAndRun(ctx, command, resolved2.target, explanation)
-      );
-    }
-  });
-}
-
-// src/lib/tools/reviewScript.ts
-import { tool as tool9 } from "ai";
-import z16 from "zod";
-import { stat as stat2 } from "node:fs/promises";
-import { relative as relative5 } from "node:path";
-function reviewScriptTool(ctx) {
-  return tool9({
-    description: "Call this as soon as the ingestion script is finished and before you run it, so the user can review it.It shows the file path and returns once they have confirmed reviewing it.",
-    inputSchema: z16.object({
-      filePath: z16.string().describe(
-        "Path to the script to review, relative to the project root."
-      )
-    }),
-    execute: async ({ filePath }) => {
-      logger.info({ filePath }, "called reviewScript tool");
-      const resolved2 = resolveInRoot(ctx, filePath);
-      if (resolved2.ok === false) return resolved2.error;
-      const isFile = await stat2(resolved2.target).then(
-        (s) => s.isFile(),
-        () => false
-      );
-      if (!isFile) {
-        return `Refused: ${filePath} is not a file. Write the script first, then review the path you wrote.`;
-      }
       return serializePrompt(async () => {
-        await useWizard.getState().requestUserInput({
-          prompt: "",
-          promptType: "enterToContinue",
-          options: [],
-          messages: [
-            `Please review ${relative5(ctx.root, resolved2.target)} before it runs:`,
-            resolved2.target
-          ]
-        });
-        ctx.reviewed.push(resolved2.target);
-        return "The user has reviewed the script. You may run it now.";
+        const lateReview = await runReviewedCommand(
+          ctx,
+          command,
+          resolved2.target
+        );
+        if (lateReview !== void 0) return lateReview;
+        const storedApprovalIsCurrent = !usedStoredApproval || useWizard.getState().isCommandApproved(command, resolved2.target);
+        if (isSafe && storedApprovalIsCurrent) {
+          return runAndRecord(ctx, command, resolved2.target);
+        }
+        return approveAndRun(ctx, command, resolved2.target, explanation);
       });
     }
   });
@@ -3509,7 +3627,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.45.0",
+  version: "0.46.0-rc.136.345",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -4212,8 +4330,8 @@ function ingestionInstructions(input) {
       ...algoliaClientDoc(input),
       "Install the Algolia client with the project's own package manager via runShell, declaring it in whatever manifest the project uses (e.g. package.json, requirements.txt, Gemfile, go.mod, composer.json) so the dependency is not just installed ad hoc.",
       `If the script loads its env vars from a file (e.g. via dotenv or an equivalent for its language) rather than the process environment directly, decide that up front and call writeCredentials on that file before you finish the script \u2014 do not wait to discover the need for it by having a writeFile call refused.`,
-      "When the script is finished, call reviewScript with its path and wait: running it writes records to a live index, so the developer reads it first. Do not run it before that call returns.",
-      'Then run the script yourself via runShell, and report the command you ran as "ingestCommand" so the developer can re-run it. Its explanation must say that running it writes records to Algolia.',
+      `When the script is finished, decide the exact command and cwd you will use to run it, 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.`,
+      'Then, without changing directories, run the script yourself via runShell using the exact same command and cwd. Report the command you ran as "ingestCommand" so the developer can re-run it. Its explanation must say that running it writes records to Algolia.',
       "The summary should be extremely concise.",
       ...sourceSpecificInstructions(input)
     ] : []
@@ -4585,19 +4703,33 @@ ${detail}` : ""}`
         product_area: "AI Wizard"
       });
     }
-    const commandMessages = ingestCommand ? [`Ingestion command: ${ingestCommand}`] : [];
-    await ctx.requestUserInput({
-      prompt: "",
-      promptType: "enterToContinue",
-      options: [],
-      // One message per line: Notices.tsx counts a message as one wrapped
-      // line, so an embedded newline overflows the panel's height accounting.
-      messages: [
-        ingestOutcomeMessage,
-        ...ingestFailureDetail?.split("\n").filter((l) => l.trim()) ?? [],
-        ...commandMessages
-      ]
-    });
+    if (ingestScriptRan) {
+      await ctx.requestUserInput({
+        prompt: "Continue",
+        promptType: "notice",
+        options: [],
+        messages: [
+          ingestOutcomeMessage,
+          "View your ingested records in the Algolia dashboard:",
+          "https://dashboard.algolia.com/explorer/browse",
+          "When you're ready to continue, we'll move on to search implementation."
+        ]
+      });
+    } else {
+      const commandMessages = ingestCommand ? [`Ingestion command: ${ingestCommand}`] : [];
+      await ctx.requestUserInput({
+        prompt: "",
+        promptType: "enterToContinue",
+        options: [],
+        // One message per line: Notices.tsx counts a message as one wrapped
+        // line, so an embedded newline overflows the panel's height accounting.
+        messages: [
+          ingestOutcomeMessage,
+          ...ingestFailureDetail?.split("\n").filter((l) => l.trim()) ?? [],
+          ...commandMessages
+        ]
+      });
+    }
   }
   let searchConfigFile;
   if (useCases.includes("search")) {
@@ -5789,7 +5921,7 @@ function App() {
 }
 
 // src/lib/envAppId.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 import { join as join12 } from "node:path";
 var ENV_FILES = [".env", ".env.local"];
 var APP_ID_LINE = /^[ \t]*(?:export[ \t]+)?([A-Z0-9_]*ALGOLIA_APP(?:LICATION)?_ID)[ \t]*=[ \t]*(.*)$/gm;
@@ -5797,7 +5929,7 @@ async function findEnvApplicationId(root = process.cwd()) {
   for (const file of ENV_FILES) {
     let content;
     try {
-      content = await readFile7(join12(root, file), "utf8");
+      content = await readFile8(join12(root, file), "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         logger.warn(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.45.0",
+  "version": "0.46.0-rc.136.345",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {