@algolia/wizard 0.12.0 → 0.13.0

package/dist/main.js

@@ -1093,9 +1093,14 @@ var sidebarItems = [
 ];
 
 // src/ui/Welcome.tsx
-import Image, { InkPictureProvider } from "ink-picture";
+import Image, { TerminalInfoContext, defaultTerminalInfo } from "ink-picture";
 import { jsx as jsx7, jsxs as jsxs8 } from "react/jsx-runtime";
 var IMAGE_PATH = join3(dirname2(fileURLToPath(import.meta.url)), "algolia.png");
+var TERMINAL_INFO = {
+  ...defaultTerminalInfo,
+  supportsUnicode: true,
+  supportsColor: true
+};
 function SidebarItem({
   title,
   description
@@ -1142,7 +1147,7 @@ function Welcome() {
         flexDirection: "column",
         justifyContent: "center",
         children: /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", gap: 2, children: [
-          /* @__PURE__ */ jsx7(InkPictureProvider, { children: /* @__PURE__ */ jsx7(
+          /* @__PURE__ */ jsx7(TerminalInfoContext.Provider, { value: TERMINAL_INFO, children: /* @__PURE__ */ jsx7(
             Image,
             {
               src: IMAGE_PATH,
@@ -2241,7 +2246,7 @@ async function ensureApplication() {
 }
 
 // src/workflows/default.ts
-import { z as z29 } from "zod";
+import { z as z28 } from "zod";
 
 // src/actions/listIndices.ts
 import { z as z5 } from "zod";
@@ -2874,102 +2879,13 @@ function searchFilesTool(ctx) {
   });
 }
 
-// src/lib/tools/verifyImplementation.ts
+// src/lib/tools/runShell.ts
 import { tool as tool8 } from "ai";
 import z15 from "zod";
-
-// src/lib/tools/utils/runCommand.ts
-import { spawn as spawn2 } from "node:child_process";
-function runCommand(command, args, cwd) {
-  return new Promise((resolve4) => {
-    let output = "";
-    const child = spawn2(command, args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    child.stdout?.on("data", (d) => output += d);
-    child.stderr?.on("data", (d) => output += d);
-    child.on(
-      "error",
-      (err) => resolve4({ code: 1, output: `Failed to run ${command}: ${err.message}` })
-    );
-    child.on("close", (code) => resolve4({ code: code ?? 1, output }));
-  });
-}
-
-// src/lib/tools/utils/packageManager.ts
-import { readFile as readFile7 } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join as join9 } from "node:path";
-var LOCKFILES = [
-  ["pnpm-lock.yaml", "pnpm"],
-  ["yarn.lock", "yarn"],
-  ["bun.lockb", "bun"],
-  ["bun.lock", "bun"],
-  ["package-lock.json", "npm"]
-];
-async function readPackageJson(cwd = process.cwd()) {
-  return JSON.parse(await readFile7(join9(cwd, "package.json"), "utf8"));
-}
-function packageManagerFrom(pkg) {
-  return pkg.packageManager?.split("@")[0] ?? "npm";
-}
-function packageManagerFromLockfile(cwd) {
-  return LOCKFILES.find(([file]) => existsSync(join9(cwd, file)))?.[1];
-}
-async function detectPackageManager(cwd) {
-  try {
-    const pkg = await readPackageJson(cwd);
-    if (pkg.packageManager) return packageManagerFrom(pkg);
-  } catch {
-  }
-  return packageManagerFromLockfile(cwd) ?? "npm";
-}
-
-// src/lib/tools/repoVerification.ts
-var VERIFICATION_SCRIPT_CANDIDATES = ["lint", "typecheck", "check"];
-async function runRepoVerificationCheck() {
-  let pkg;
-  try {
-    pkg = await readPackageJson();
-  } catch (err) {
-    const limitation = `Could not read package.json to detect verification conventions: ${err.message}`;
-    return { ok: false, checks: [], limitation };
-  }
-  const scripts = pkg.scripts ?? {};
-  const present = VERIFICATION_SCRIPT_CANDIDATES.filter((s) => s in scripts);
-  if (present.length === 0) {
-    const limitation = `No verification script found in package.json (looked for: ${VERIFICATION_SCRIPT_CANDIDATES.join(", ")}).`;
-    return { ok: false, checks: [], limitation };
-  }
-  const pm = await detectPackageManager(process.cwd());
-  const checks = [];
-  for (const script of present) {
-    const command = `${pm} run ${script}`;
-    const { code, output } = await runCommand(pm, ["run", script]);
-    checks.push({ command, exitCode: code, ok: code === 0, output: output.trim() });
-  }
-  return { ok: checks.every((c) => c.ok), checks };
-}
-
-// src/lib/tools/verifyImplementation.ts
-function verifyImplementationTool() {
-  return tool8({
-    description: "Run the repo's mechanical verification check for generated implementation changes. Detects lint/typecheck/check from package.json and returns structured pass/fail evidence for the verifier to interpret.",
-    inputSchema: z15.object(),
-    execute: async () => {
-      logger.info("called verifyImplementation tool");
-      return runRepoVerificationCheck();
-    }
-  });
-}
-
-// src/lib/tools/runShell.ts
-import { tool as tool9 } from "ai";
-import z16 from "zod";
+import { relative as relative2 } from "node:path";
 
 // src/lib/tools/utils/runShell.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 
 // src/lib/tools/context.ts
 var DEFAULT_TOOL_LIMITS = {
@@ -3024,7 +2940,7 @@ function runShell(command, opts) {
     let output = "";
     let timedOut = false;
     let settled = false;
-    const child = spawn3(command, {
+    const child = spawn2(command, {
       shell: true,
       cwd: opts.cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -3061,6 +2977,21 @@ function runShell(command, opts) {
 }
 
 // src/lib/tools/runShell.ts
+function storeApproval(root) {
+  return async (req) => {
+    const rel = relative2(root, req.cwd);
+    const answer = await useWizard.getState().requestUserInput({
+      prompt: "Run this command?",
+      promptType: "commandApproval",
+      options: [],
+      command: {
+        ...req,
+        cwd: rel === "" || rel.startsWith("..") ? req.cwd : rel
+      }
+    });
+    return answer === "approve" ? "approve" : "reject";
+  };
+}
 var shellChain = Promise.resolve();
 function serialize(work) {
   const result = shellChain.then(work);
@@ -3111,16 +3042,16 @@ async function approveAndRun(ctx, command, cwd, explanation) {
   };
 }
 function runShellTool(ctx) {
-  return tool9({
+  return tool8({
     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. The user sees and approves every command before it runs, so write a clear `explanation`. If the user rejects a command, do not retry it \u2014 propose a different approach.",
-    inputSchema: z16.object({
-      command: z16.string().describe(
+    inputSchema: z15.object({
+      command: z15.string().describe(
         "The command to run, exactly as it would be typed in a shell. Pipes, && and redirects are allowed."
       ),
-      cwd: z16.string().optional().describe(
+      cwd: z15.string().optional().describe(
         "Directory to run in, relative to the project root. Defaults to the project root."
       ),
-      explanation: z16.string().describe(
+      explanation: z15.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."
       )
     }),
@@ -3139,12 +3070,12 @@ function runShellTool(ctx) {
 }
 
 // src/lib/tools/generateRecord.ts
-import { tool as tool10, generateText, Output, NoObjectGeneratedError } from "ai";
+import { tool as tool9, generateText, Output, NoObjectGeneratedError } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { nanoid as nanoid2 } from "nanoid";
 import { mkdir as mkdir5, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname6 } from "node:path";
-import z17 from "zod";
+import z16 from "zod";
 var DATA_DIR = ".algolia-wizard/data";
 var RECORD_MODEL = "claude-haiku-4-5";
 var MAX_RECORDS = 100;
@@ -3154,19 +3085,19 @@ var anthropic = createAnthropic({
   apiKey: process.env.PROVIDER_API_KEY ?? ""
 });
 function generateRecordTool(ctx) {
-  return tool10({
+  return tool9({
     description: "Generate realistic sample records for an entity and write them to a JSON file in the worktree. Provide the entity name and its attributes; this tool asks a model to invent varied, realistic values, each with a unique objectID, and returns the file path to read them from at runtime. Do not invent the record values or objectIDs yourself, and do not inline the returned records into the script \u2014 call this tool and read the file it writes.",
-    inputSchema: z17.object({
-      entityName: z17.string().describe("Name of the entity to generate records for."),
-      attributes: z17.array(z17.string()).describe("Attribute names each record must contain."),
-      count: z17.number().int().min(1).max(MAX_RECORDS).default(10).describe(`How many records to generate (max ${MAX_RECORDS}).`),
-      hint: z17.string().optional().describe("Optional context to steer realistic values.")
+    inputSchema: z16.object({
+      entityName: z16.string().describe("Name of the entity to generate records for."),
+      attributes: z16.array(z16.string()).describe("Attribute names each record must contain."),
+      count: z16.number().int().min(1).max(MAX_RECORDS).default(10).describe(`How many records to generate (max ${MAX_RECORDS}).`),
+      hint: z16.string().optional().describe("Optional context to steer realistic values.")
     }),
     execute: async ({ entityName, attributes, count, hint }) => {
       logger.info({ entityName, count }, "called generateRecord tool");
       try {
-        const value = z17.union([z17.string(), z17.number(), z17.boolean(), z17.null()]);
-        const recordSchema = z17.object(
+        const value = z16.union([z16.string(), z16.number(), z16.boolean(), z16.null()]);
+        const recordSchema = z16.object(
           Object.fromEntries(attributes.map((attr) => [attr, value]))
         );
         const generateBatch = async (batchCount) => {
@@ -3176,8 +3107,8 @@ function generateRecordTool(ctx) {
               const { output } = await generateText({
                 model: anthropic(RECORD_MODEL),
                 output: Output.object({
-                  schema: z17.object({
-                    records: z17.array(recordSchema).length(batchCount)
+                  schema: z16.object({
+                    records: z16.array(recordSchema).length(batchCount)
                   })
                 }),
                 prompt: [
@@ -3234,13 +3165,13 @@ function generateRecordTool(ctx) {
 }
 
 // src/lib/tools/notifyUser.ts
-import { tool as tool11 } from "ai";
-import z18 from "zod";
+import { tool as tool10 } from "ai";
+import z17 from "zod";
 function notifyUserTool() {
-  return tool11({
+  return tool10({
     description: `Give the user a brief, high-level update on what you are currently doing or about to do next. This is for the big picture (e.g. "Reading through your data models", "Writing the search UI") \u2014 not granular detail like individual tool calls, which are already logged separately. Call it when you start a new phase of work or your focus shifts, just not on every step, enough to keep the user engaged. Don't say things like "starting", just describe what you are doing. Don't mention tool calls themselves, just general direction of the work.`,
-    inputSchema: z18.object({
-      message: z18.string().describe(
+    inputSchema: z17.object({
+      message: z17.string().describe(
         "Short, plain-language description of what you are doing now."
       )
     }),
@@ -3283,10 +3214,6 @@ function createTools(ctx, { output, tools }) {
       writeCredentialsTool(ctx)
     ),
     searchFiles: withLogging("searchFiles", searchFilesTool(ctx)),
-    verifyImplementation: withLogging(
-      "verifyImplementation",
-      verifyImplementationTool()
-    ),
     runShell: withLogging("runShell", runShellTool(ctx)),
     generateRecord: withLogging("generateRecord", generateRecordTool(ctx)),
     notifyUser: withLogging("notifyUser", notifyUserTool())
@@ -3409,10 +3336,10 @@ async function runAgent(req) {
 }
 
 // src/actions/detectLanguage.ts
-import z21 from "zod";
-var detectLanguageSchema = z21.object({
-  languages: z21.array(z21.object({ name: z21.string(), version: z21.string() })),
-  frameworks: z21.array(z21.object({ name: z21.string(), version: z21.string() }))
+import z20 from "zod";
+var detectLanguageSchema = z20.object({
+  languages: z20.array(z20.object({ name: z20.string(), version: z20.string() })),
+  frameworks: z20.array(z20.object({ name: z20.string(), version: z20.string() }))
 });
 var detectLanguage = () => runAgent({
   instructions: [
@@ -3430,31 +3357,31 @@ var detectLanguage = () => runAgent({
 });
 
 // src/actions/analyzeCodebase.ts
-import z22 from "zod";
+import z21 from "zod";
 var READONLY_TOOLS = [
   "listFiles",
   "changeDirectory",
   "readFile",
   "searchFiles"
 ];
-var ingestionAnalysisSchema = z22.object({
-  ingestionAnalysis: z22.array(
-    z22.object({
-      name: z22.string(),
-      paths: z22.array(z22.string()),
+var ingestionAnalysisSchema = z21.object({
+  ingestionAnalysis: z21.array(
+    z21.object({
+      name: z21.string(),
+      paths: z21.array(z21.string()),
       // indexable fields the agent found for this entity
-      attributes: z22.array(z22.string())
+      attributes: z21.array(z21.string())
     })
   )
 });
-var searchImplementationAnalysisSchema = z22.object({
-  searchImplementationAnalysis: z22.string()
+var searchImplementationAnalysisSchema = z21.object({
+  searchImplementationAnalysis: z21.string()
 });
-var verificationSchema = z22.object({
-  verification: z22.array(z22.string())
+var verificationSchema = z21.object({
+  verification: z21.array(z21.string())
 });
 var confirmedEntitiesFieldSchema = ingestionAnalysisSchema.shape.ingestionAnalysis.optional();
-var analyzeCodebaseSchema = z22.object({
+var analyzeCodebaseSchema = z21.object({
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   searchImplementationAnalysis: searchImplementationAnalysisSchema.shape.searchImplementationAnalysis.optional(),
   verification: verificationSchema.shape.verification.optional(),
@@ -3516,7 +3443,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.12.0",
+  version: "0.13.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3635,8 +3562,8 @@ async function askList(ctx, prompt, { required = false } = {}) {
 }
 
 // src/actions/confirmLanguage.ts
-import z24 from "zod";
-var confirmLanguageSchema = z24.object({
+import z23 from "zod";
+var confirmLanguageSchema = z23.object({
   languages: detectLanguageSchema.shape.languages
 });
 async function confirmLanguage(ctx) {
@@ -3657,8 +3584,8 @@ async function confirmLanguage(ctx) {
 }
 
 // src/actions/confirmFramework.ts
-import z25 from "zod";
-var confirmFrameworkSchema = z25.object({
+import z24 from "zod";
+var confirmFrameworkSchema = z24.object({
   frameworks: detectLanguageSchema.shape.frameworks
 });
 var CURATED_FRAMEWORKS = [
@@ -3786,8 +3713,8 @@ async function promptUser(ctx, params) {
 }
 
 // src/actions/confirmEntities.ts
-import z26 from "zod";
-var confirmEntitiesSchema = z26.object({
+import z25 from "zod";
+var confirmEntitiesSchema = z25.object({
   // Final detection — the focused re-run may supersede project-scan's.
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   confirmedEntities: confirmedEntitiesFieldSchema
@@ -3857,15 +3784,15 @@ async function confirmEntities(ctx) {
 }
 
 // src/actions/review.ts
-import { z as z27 } from "zod";
-var reviewSchema = z27.object({
+import { z as z26 } from "zod";
+var reviewSchema = z26.object({
   // Broad, high-level takeaways grouped by theme (e.g. ingestion, search UI),
   // not one entry per workflow step — a step's raw output can be a long,
   // multi-paragraph blob (see implement.ts's summaries.join), and mirroring
   // that 1:1 is what made the old per-step summary an unreadable wall of text.
-  summaryPoints: z27.array(z27.string()),
-  reviewPrompt: z27.string(),
-  nextSteps: z27.array(z27.string())
+  summaryPoints: z26.array(z26.string()),
+  reviewPrompt: z26.string(),
+  nextSteps: z26.array(z26.string())
 });
 function formatCompletedSteps(steps) {
   if (!steps.length) return "(no prior steps completed)";
@@ -3916,19 +3843,12 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 };
 
 // src/actions/implement.ts
-import z28 from "zod";
+import z27 from "zod";
 
 // src/lib/worktree.ts
-import { execFile, spawn as spawn4 } from "node:child_process";
-import { copyFile, mkdir as mkdir6, readdir as readdir3, readFile as readFile8, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
-import {
-  basename as basename2,
-  dirname as dirname7,
-  isAbsolute as isAbsolute2,
-  join as join10,
-  relative as relative2,
-  resolve as resolve3
-} from "node:path";
+import { execFile } from "node:child_process";
+import { copyFile, mkdir as mkdir6, readdir as readdir3, readFile as readFile7, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute2, join as join9, resolve as resolve3 } from "node:path";
 var MAX_BUFFER = 32 * 1024 * 1024;
 var MAX_WIZARD_WORKTREES = 3;
 var WIZARD_BRANCH_PREFIX = "wizard/implement-";
@@ -3959,7 +3879,7 @@ async function isWorkingTreeDirty(repoRoot) {
   return out.trim().length > 0;
 }
 async function pruneOldWorktrees(repoRoot) {
-  const dir = join10(stateDir(repoRoot), "worktrees");
+  const dir = join9(stateDir(repoRoot), "worktrees");
   const stale = (await readdir3(dir).catch(() => [])).filter((name) => /^wizard-implement-\d+$/.test(name)).sort().reverse().slice(MAX_WIZARD_WORKTREES - 1);
   for (const slug of stale) {
     const branch = slug.replace("wizard-implement-", WIZARD_BRANCH_PREFIX);
@@ -3970,7 +3890,7 @@ async function pruneOldWorktrees(repoRoot) {
         "worktree",
         "remove",
         "--force",
-        join10(dir, slug)
+        join9(dir, slug)
       ]);
       await git(["-C", repoRoot, "branch", "-D", branch]);
     } catch (err) {
@@ -3984,113 +3904,13 @@ async function pruneOldWorktrees(repoRoot) {
 async function createWorktree(repoRoot) {
   const branch = `${WIZARD_BRANCH_PREFIX}${Date.now()}`;
   const dirSlug = branch.replace(/\//g, "-");
-  const path = join10(stateDir(repoRoot), "worktrees", dirSlug);
+  const path = join9(stateDir(repoRoot), "worktrees", dirSlug);
   await git(["-C", repoRoot, "worktree", "prune"]);
   await pruneOldWorktrees(repoRoot);
   await mkdir6(dirname7(path), { recursive: true });
   await git(["-C", repoRoot, "worktree", "add", "-b", branch, path, "HEAD"]);
   return { path, branch };
 }
-async function installWorktreeDeps(worktreePath) {
-  try {
-    await readPackageJson(worktreePath);
-  } catch {
-    return { ok: true, output: "no package.json; skipped install" };
-  }
-  const pm = await detectPackageManager(worktreePath);
-  return new Promise((resolve4) => {
-    let output = "";
-    const child = spawn4(pm, ["install"], {
-      cwd: worktreePath,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    child.stdout?.on("data", (d) => output += d);
-    child.stderr?.on("data", (d) => output += d);
-    child.on(
-      "error",
-      (err) => resolve4({
-        ok: false,
-        output: `Failed to run ${pm} install: ${err.message}`
-      })
-    );
-    child.on(
-      "close",
-      (code) => resolve4({ ok: code === 0, output: output.trim() })
-    );
-  });
-}
-var INGEST_RUNTIMES = ["node", "python", "python3", "bun"];
-function validateIngestEntrypoint(worktreePath, entrypoint) {
-  if (!entrypoint || entrypoint.startsWith("-")) {
-    return {
-      ok: false,
-      reason: `entrypoint "${entrypoint}" is not a plain file path`
-    };
-  }
-  const target = resolve3(worktreePath, entrypoint);
-  const rel = relative2(worktreePath, target);
-  if (rel.startsWith("..") || isAbsolute2(rel)) {
-    return {
-      ok: false,
-      reason: `entrypoint "${entrypoint}" resolves outside the worktree`
-    };
-  }
-  return { ok: true, target };
-}
-async function runIngestScript(worktreePath, runtime, entrypoint, env = {}) {
-  if (!INGEST_RUNTIMES.includes(runtime)) {
-    return {
-      ran: false,
-      ok: false,
-      output: "",
-      reason: `runtime "${runtime}" is not an allowed interpreter (${INGEST_RUNTIMES.join(", ")})`
-    };
-  }
-  const validated = validateIngestEntrypoint(worktreePath, entrypoint);
-  if (!validated.ok) {
-    return { ran: false, ok: false, output: "", reason: validated.reason };
-  }
-  try {
-    if (!(await stat2(validated.target)).isFile()) {
-      return {
-        ran: false,
-        ok: false,
-        output: "",
-        reason: `entrypoint "${entrypoint}" is not a file`
-      };
-    }
-  } catch {
-    return {
-      ran: false,
-      ok: false,
-      output: "",
-      reason: `entrypoint "${entrypoint}" does not exist`
-    };
-  }
-  return new Promise((resolveRun) => {
-    let output = "";
-    const child = spawn4(runtime, [entrypoint], {
-      cwd: worktreePath,
-      shell: false,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, ...env }
-    });
-    child.stdout?.on("data", (d) => output += d);
-    child.stderr?.on("data", (d) => output += d);
-    child.on(
-      "error",
-      (err) => resolveRun({
-        ran: true,
-        ok: false,
-        output: `Failed to run ${runtime} ${entrypoint}: ${err.message}`
-      })
-    );
-    child.on(
-      "close",
-      (code) => resolveRun({ ran: true, ok: code === 0, output: output.trim() })
-    );
-  });
-}
 async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourcePath) {
   const trimmed = sourcePath.trim();
   if (!trimmed) {
@@ -4104,8 +3924,8 @@ async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourceP
   } catch {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
-  const relPath = join10(ingestDir, basename2(source));
-  const dest = join10(worktreePath, relPath);
+  const relPath = join9(ingestDir, basename2(source));
+  const dest = join9(worktreePath, relPath);
   try {
     await mkdir6(dirname7(dest), { recursive: true });
     await copyFile(source, dest);
@@ -4123,7 +3943,7 @@ function hasEnvVar(content, name) {
 async function readEnvVar(worktreePath, name) {
   let content;
   try {
-    content = await readFile8(join10(worktreePath, ".env"), "utf8");
+    content = await readFile7(join9(worktreePath, ".env"), "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
     return void 0;
@@ -4138,10 +3958,10 @@ async function readEnvVar(worktreePath, name) {
   return value;
 }
 async function writeSearchEnvValues(worktreePath, vars) {
-  const target = join10(worktreePath, ".env");
+  const target = join9(worktreePath, ".env");
   let existing = "";
   try {
-    existing = await readFile8(target, "utf8");
+    existing = await readFile7(target, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -4210,15 +4030,15 @@ async function confirmDirtyWorkingTree(ctx, repoRoot) {
 }
 
 // src/lib/algoliaDocs.ts
-import { readFileSync, readdirSync, existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname8, join as join11 } from "node:path";
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { dirname as dirname8, join as join10 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var DOCS_SUBPATH = join11("docs", "algolia-sdk");
+var DOCS_SUBPATH = join10("docs", "algolia-sdk");
 function findDocsDir() {
   let dir = dirname8(fileURLToPath2(import.meta.url));
   for (; ; ) {
-    const candidate = join11(dir, DOCS_SUBPATH);
-    if (existsSync2(candidate)) return candidate;
+    const candidate = join10(dir, DOCS_SUBPATH);
+    if (existsSync(candidate)) return candidate;
     const parent = dirname8(dir);
     if (parent === dir) return void 0;
     dir = parent;
@@ -4240,7 +4060,7 @@ function loadAlgoliaDoc(language) {
     );
     return "";
   }
-  return readFileSync(join11(docsDir, files[0]), "utf8").trim();
+  return readFileSync(join10(docsDir, files[0]), "utf8").trim();
 }
 function getNamedDoc(name, language) {
   const docsDir = findDocsDir();
@@ -4248,8 +4068,8 @@ function getNamedDoc(name, language) {
     logger.warn("docs/algolia-sdk not found");
     return "";
   }
-  const file = join11(docsDir, `${name}-${language}.md`);
-  if (!existsSync2(file)) {
+  const file = join10(docsDir, `${name}-${language}.md`);
+  if (!existsSync(file)) {
     logger.warn({ name, language }, "named SDK reference not found");
     return "";
   }
@@ -4275,34 +4095,30 @@ function shellQuote(value) {
 }
 
 // src/actions/implement.ts
-var implementSchema = z28.object({
-  filesChanged: z28.array(z28.string()),
-  summary: z28.string(),
-  worktreePath: z28.string().optional(),
-  ingestCommand: z28.string().optional(),
-  ingestScriptRan: z28.boolean().optional(),
-  ingestRecordCount: z28.number().optional(),
-  ingestDurationMs: z28.number().optional(),
-  ingestionSource: z28.enum(["local", "fileUpload", "generated"]),
-  searchEnvVars: z28.array(
-    z28.object({
-      name: z28.string(),
-      value: z28.string()
+var implementSchema = z27.object({
+  filesChanged: z27.array(z27.string()),
+  summary: z27.string(),
+  worktreePath: z27.string().optional(),
+  ingestCommand: z27.string().optional(),
+  ingestScriptRan: z27.boolean().optional(),
+  ingestRecordCount: z27.number().optional(),
+  ingestDurationMs: z27.number().optional(),
+  ingestionSource: z27.enum(["local", "fileUpload", "generated"]),
+  searchEnvVars: z27.array(
+    z27.object({
+      name: z27.string(),
+      value: z27.string()
     })
   ).optional()
 });
-var implementationOutputSchema = z28.object({
-  summary: z28.string(),
-  // Ingestion only: a structured pair the wizard turns into an argv, never a
-  // free-form command string. `runtime` is allowlisted and `entrypoint` is
-  // validated worktree-relative, so the agent cannot inject extra commands.
-  runtime: z28.enum(INGEST_RUNTIMES).optional(),
-  entrypoint: z28.string().optional()
+var implementationOutputSchema = z27.object({
+  summary: z27.string(),
+  ingestCommand: z27.string().optional()
 });
-var verificationOutputSchema = z28.object({
-  summary: z28.string(),
-  sufficient: z28.boolean(),
-  additionalInstructions: z28.string().optional()
+var verificationOutputSchema = z27.object({
+  summary: z27.string(),
+  sufficient: z27.boolean(),
+  additionalInstructions: z27.string().optional()
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
@@ -4382,7 +4198,9 @@ function baseInstructions(input) {
     // index-scoped keys then reject with a 403.
     `Target Algolia index, to be used exactly as written \u2014 never renamed, re-cased, prefixed, or suffixed: "${input.targetIndex}"`,
     `Project languages and frameworks: ${JSON.stringify(input.language)}`,
-    "Make minimal, idiomatic changes; do not touch unrelated code."
+    "Make minimal, idiomatic changes; do not touch unrelated code.",
+    `Commands run through a shell on ${process.platform}. Write commands that work there.`,
+    "runShell needs the developer to approve each command, so give every call a clear `explanation` naming what it does and any side effect. If a command is rejected, do not retry it \u2014 take a different approach or report the limitation."
   ];
 }
 function sourceSpecificInstructions(input) {
@@ -4418,9 +4236,9 @@ function ingestionInstructions(input) {
       "Use the appropriate Algolia package in the ingestion script. Do not use the raw HTTP API.",
       "After a successful ingest, the script must print exactly one line to stdout in the form `ALGOLIA_WIZARD_RECORD_COUNT=<n>`, where <n> is the total number of records pushed to Algolia. Print it last, on its own line, with no surrounding text.",
       getNamedDoc("save-records", "js"),
-      'Add algoliasearch to package.json "dependencies" with a valid version range; the wizard installs the worktree deps after you finish.',
+      'Install the Algolia client via runShell and add it to package.json "dependencies" with a valid version range, so the dependency is not just installed ad hoc.',
+      '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.',
       "The summary should be extremely concise.",
-      `Return how to run the script as two fields, not a command string: "runtime" (one of ${INGEST_RUNTIMES.join(", ")}) and "entrypoint" (the script path relative to the worktree root, e.g. "${input.ingestDir}/ingest.mjs"). The wizard runs \`<runtime> <entrypoint>\` directly, so the entrypoint must be a plain path with no flags or arguments. Write a script one of those interpreters can run as-is.`,
       ...sourceSpecificInstructions(input)
     ] : []
   ];
@@ -4434,6 +4252,7 @@ function searchInstructions(input) {
     doc,
     `Add the search UI at ${input.searchLocation ? `"${input.searchLocation}"` : "the best shared, always-rendered layout location (e.g. a header/nav component)"} so it is reachable across the app \u2014 at least a working SearchBox and Hits against the target index.`,
     `Read the index name from the ${searchIndexVar(input.language)} env var, which the wizard sets to "${input.targetIndex}". Never hardcode an index name or derive one from the project, file, or component name.`,
+    "Read the App ID, the search-only API key, and the index name from env vars; never hardcode them. A search-only key is safe to expose client-side.",
     // The key is provisioned only after verification passes, so the agent never
     // sees one. It must also leave .env alone: the wizard reads that file to
     // decide whether a key already exists, and an agent-invented value there
@@ -4443,8 +4262,7 @@ function searchInstructions(input) {
     // ".env" right after this step, so a renamed prefix would leave the code
     // reading a var the wizard never wrote.
     `Use exactly these public env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
-    "Read the App ID, the search-only API key, and the index name from public env vars; never hardcode them. A search-only key is safe to expose client-side.",
-    'Add any Algolia/InstantSearch packages you import to package.json "dependencies" with a valid version range; the wizard installs them in the worktree after you finish.',
+    'Install any Algolia/InstantSearch packages you import via runShell, and add them to package.json "dependencies" with a valid version range.',
     "The summary should be extremely concise; do not mention env var setup or manual testing steps \u2014 the wizard writes the resolved credentials to .env and reports that separately."
   ];
 }
@@ -4452,11 +4270,12 @@ function verificationInstructions(input) {
   return [
     "Verify the Algolia implementation changes in the current worktree.",
     `Verification tools found in the codebase: ${JSON.stringify(input.findings.verification ?? [])}.`,
-    "Call verifyImplementation at least once; it runs every repo-defined lint/typecheck/check script and returns per-check results plus an aggregate ok.",
-    "For issues caused by the implementation, make minimal fixes with writeFile and re-run verifyImplementation.",
-    "Do not make speculative fixes when verifyImplementation cannot run, no checks exist, or failures are unrelated to these changes \u2014 note the limitation in your summary.",
+    "Run the project's own checks (lint, type check, tests) via runShell, using the commands the project actually defines \u2014 its task runner, manifest scripts, or Makefile. Run every check that applies, not just the first.",
+    "This worktree starts with no installed dependencies. If a check fails because packages or modules are missing, install the dependencies via runShell and re-run it rather than changing the code.",
+    "For issues caused by the implementation, make minimal fixes with writeFile and re-run the checks.",
+    "Do not make speculative fixes when no checks exist, a check cannot run, or failures are unrelated to these changes \u2014 note the limitation in your summary.",
     "Do not add new Algolia functionality here; only validate and make minimal correctness fixes.",
-    `Do not modify "${input.ingestDir}/" unless verifyImplementation reports an actionable issue in its files.`,
+    `Do not modify "${input.ingestDir}/" unless a check reports an actionable issue in its files.`,
     "Always call reportStatus with status=success once verification has run, even when sufficient=false.",
     "Set sufficient=true only when the implementation is complete and checks pass (or fail for a clearly unrelated reason).",
     "Set sufficient=false when the implementation is incomplete or has implementation-caused failures; include concrete additionalInstructions for the next pass."
@@ -4477,14 +4296,15 @@ var IMPLEMENT_CONFIG = {
   }
 };
 var useCaseToolMap = {
-  ingestion: [...FS_READ_TOOLS, "writeFile", "writeCredentials", "notifyUser"],
-  search: [...FS_READ_TOOLS, "writeFile", "notifyUser"],
-  verification: [
+  ingestion: [
     ...FS_READ_TOOLS,
     "writeFile",
-    "verifyImplementation",
+    "writeCredentials",
+    "runShell",
     "notifyUser"
-  ]
+  ],
+  search: [...FS_READ_TOOLS, "writeFile", "runShell", "notifyUser"],
+  verification: [...FS_READ_TOOLS, "writeFile", "runShell", "notifyUser"]
 };
 function toolsForUseCase(useCase, ingestionSource) {
   const tools = useCaseToolMap[useCase];
@@ -4507,15 +4327,51 @@ function formatSummary(useCase, summary) {
   const label = useCase === "ingestion" ? "Ingestion" : useCase === "search" ? "Search" : "Verification";
   return `${label}: ${summary}`;
 }
-function buildIngestCommand(worktree, runtime, entrypoint) {
-  return `cd ${shellQuote(worktree)} && ${runtime} ${shellQuote(entrypoint)}`;
-}
 function parseIngestRecordCount(output) {
   const match = output.match(/ALGOLIA_WIZARD_RECORD_COUNT=(\d+)/);
   if (!match) return void 0;
   const count = Number(match[1]);
   return Number.isFinite(count) ? count : void 0;
 }
+function ingestOutcome(executions, ingestCommand) {
+  const newestFirst = [...executions].reverse();
+  const withCount = newestFirst.filter(
+    (e) => parseIngestRecordCount(e.output ?? "") != null
+  );
+  const succeeded = newestFirst.filter((e) => e.approved && e.exitCode === 0);
+  return {
+    run: succeeded.find((e) => e.command === ingestCommand) ?? succeeded.find((e) => withCount.includes(e)),
+    attempt: ingestCommand ? newestFirst.find((e) => e.command === ingestCommand) : void 0,
+    recordCount: parseIngestRecordCount(withCount[0]?.output ?? "")
+  };
+}
+var INGEST_OUTPUT_TAIL_CHARS = 400;
+function outputTail(output) {
+  const trimmed = output?.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length > INGEST_OUTPUT_TAIL_CHARS ? `\u2026${trimmed.slice(-INGEST_OUTPUT_TAIL_CHARS)}` : trimmed;
+}
+function ingestFailure(attempt, executions) {
+  if (!attempt) {
+    return {
+      reason: executions.some((e) => !e.approved) ? "a command it needed was declined" : "no successful run was recorded"
+    };
+  }
+  if (!attempt.approved) return { reason: "you declined to run it" };
+  const detail = outputTail(attempt.output);
+  if (attempt.timedOut) {
+    const seconds = Math.round((attempt.durationMs ?? 0) / 1e3);
+    return { reason: `it timed out after ${seconds}s`, detail };
+  }
+  return { reason: `it failed (exit ${attempt.exitCode ?? "unknown"})`, detail };
+}
+function makeToolContext(worktree, env = async () => ({})) {
+  return createToolContext(
+    DEFAULT_TOOL_LIMITS,
+    worktree,
+    createShellContext({ env, approve: storeApproval(worktree) })
+  );
+}
 function verificationRetryInstructions(verification) {
   return [
     `Implementation insufficient. Address these findings before reporting completion: ${verification.additionalInstructions ?? verification.summary}`
@@ -4594,9 +4450,13 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
   const confirmed2 = normalized.confirmedEntities;
   const searchLocation = normalized.searchImplementationAnalysis;
   let appId;
+  let ingestAppId;
   if (useCases.includes("search")) {
     appId = (await requireApplication()).id;
   }
+  if (useCases.includes("ingestion")) {
+    ingestAppId = appId ?? (await requireApplication()).id;
+  }
   const worktree = existingWorktreePath ?? (await createWorktree(repoRoot)).path;
   try {
     process.chdir(worktree);
@@ -4654,41 +4514,31 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     }
     let finalSearchEnvVars = input.searchEnvVars;
     let agentRuns = 0;
-    let ingestRuntime;
-    let ingestEntrypoint;
+    let ingestCommand;
     let ingestScriptRan = false;
     let ingestRecordCount;
     let ingestDurationMs;
-    let installFailed = false;
     let ingestOutcomeMessage;
+    const ingestKeyAppId = ingestAppId;
+    const ingestionTools = ingestKeyAppId ? makeToolContext(worktree, async () => ({
+      [APP_ID_VAR]: ingestKeyAppId,
+      [API_KEY_VAR]: (await resolveWriteKey(targetIndex, ingestKeyAppId)).key,
+      [INDEX_NAME_VAR]: targetIndex
+    })) : void 0;
+    const searchTools = makeToolContext(worktree);
     async function runImplementationUseCase(currentUseCase, extraInstructions = []) {
       if (agentRuns > 0) ctx.recordStepExecution();
       agentRuns += 1;
-      const result = await runAgent({
+      return runAgent({
         instructions: buildAgentInstructions(
           currentUseCase,
           input,
           extraInstructions
         ),
         tools: toolsForUseCase(currentUseCase, input.ingestionSource),
-        outputSchema: implementationOutputSchema
-      });
-      ctx.notify({
-        messages: [`Installing dependencies for ${currentUseCase}\u2026`]
-      });
-      const installLogId = ctx.logStart("installWorktreeDeps", {
-        useCase: currentUseCase
+        outputSchema: implementationOutputSchema,
+        toolContext: currentUseCase === "ingestion" ? ingestionTools ?? searchTools : searchTools
       });
-      const install = await installWorktreeDeps(worktree);
-      ctx.logEnd(installLogId, install.ok ? "success" : "error");
-      if (!install.ok) {
-        installFailed = true;
-        logger.warn(
-          { useCase: currentUseCase, output: install.output },
-          "implement: dependency install in worktree failed; generated commands may not run until deps are installed"
-        );
-      }
-      return result;
     }
     async function runVerificationUseCase() {
       if (agentRuns > 0) ctx.recordStepExecution();
@@ -4696,111 +4546,75 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       return runAgent({
         instructions: buildAgentInstructions("verification", input),
         tools: toolsForUseCase("verification"),
-        outputSchema: verificationOutputSchema
+        outputSchema: verificationOutputSchema,
+        toolContext: searchTools
       });
     }
     if (useCases.includes("ingestion")) {
-      const { summary, runtime, entrypoint } = await runImplementationUseCase("ingestion");
-      summaries.push(formatSummary("ingestion", summary));
-      ingestRuntime = runtime;
-      ingestEntrypoint = entrypoint;
-      if (ingestRuntime && ingestEntrypoint && !installFailed) {
-        ctx.clearNotices();
-        const runNow = await ctx.requestUserInput({
-          prompt: `Run the ingestion script now? This writes records to the "${targetIndex}" index.`,
-          promptType: "acceptReject",
-          options: ["Yes", "No"],
-          messages: []
-        }) === true;
-        if (runNow) {
-          const ingestApp = await requireApplication();
-          const writeKey = (await resolveWriteKey(targetIndex, ingestApp.id)).key;
-          ctx.notify({ messages: [`Writing records to "${targetIndex}"\u2026`] });
-          const scriptLogId = ctx.logStart("runIngestScript", {
-            runtime: ingestRuntime,
-            entrypoint: ingestEntrypoint
+      let ingestFailureDetail;
+      const result = await runImplementationUseCase("ingestion");
+      summaries.push(formatSummary("ingestion", result.summary));
+      ingestCommand = result.ingestCommand;
+      const executions = (ingestionTools ?? searchTools).shell.executions;
+      const {
+        run: ingestRun,
+        attempt: ingestAttempt,
+        recordCount
+      } = ingestOutcome(executions, ingestCommand);
+      ingestScriptRan = ingestRun != null;
+      ingestRecordCount = recordCount;
+      ingestDurationMs = ingestRun?.durationMs;
+      if (ingestScriptRan) {
+        ingestOutcomeMessage = `\u2705 Ingestion succeeded${ingestRecordCount != null ? ` \u2014 ${ingestRecordCount} record(s) indexed.` : "."}`;
+        if (ingestRecordCount != null) {
+          track("AI Wizard Ingest Successful", {
+            entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
+            record_count: ingestRecordCount,
+            duration_ms: ingestDurationMs ?? 0
           });
-          const startedAt = Date.now();
-          const run2 = await runIngestScript(
-            worktree,
-            ingestRuntime,
-            ingestEntrypoint,
-            {
-              [APP_ID_VAR]: ingestApp.id,
-              [API_KEY_VAR]: writeKey,
-              [INDEX_NAME_VAR]: targetIndex
-            }
-          );
-          ctx.logEnd(scriptLogId, run2.ok ? "success" : "error");
-          ingestScriptRan = run2.ran && run2.ok;
-          if (ingestScriptRan) {
-            ingestDurationMs = Date.now() - startedAt;
-            ingestRecordCount = parseIngestRecordCount(run2.output);
-            if (ingestRecordCount != null) {
-              track("AI Wizard Ingest Successful", {
-                entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
-                record_count: ingestRecordCount,
-                duration_ms: ingestDurationMs
-              });
-            }
-          }
-          let summaryLine;
-          let outcomeMessage;
-          if (!run2.ran) {
-            summaryLine = `\u26A0\uFE0F Skipped running the ingestion script: ${run2.reason}`;
-            outcomeMessage = `\u26A0\uFE0F The ingestion script did not run: ${run2.reason}`;
-            logger.warn(
-              {
-                runtime: ingestRuntime,
-                entrypoint: ingestEntrypoint,
-                reason: run2.reason
-              },
-              "implement: refused to auto-run ingestion script"
-            );
-            track("Error", {
-              step: "Push Data",
-              error: `ingestion script skipped: ${run2.reason}`,
-              product_area: "AI Wizard"
-            });
-          } else if (run2.ok) {
-            const status = "Ingestion run: succeeded.";
-            summaryLine = run2.output ? `${status}
-${run2.output}` : status;
-            outcomeMessage = `\u2705 Ingestion succeeded${ingestRecordCount != null ? ` \u2014 ${ingestRecordCount} record(s) indexed.` : "."}`;
-          } else {
-            const status = "\u26A0\uFE0F Ingestion run failed:";
-            summaryLine = run2.output ? `${status}
-${run2.output}` : status;
-            outcomeMessage = `\u274C Ingestion failed.${run2.output ? ` ${run2.output}` : ""}`;
-            logger.warn(
-              {
-                runtime: ingestRuntime,
-                entrypoint: ingestEntrypoint,
-                output: run2.output
-              },
-              "implement: ingestion script run failed"
-            );
-            track("Error", {
-              step: "Push Data",
-              error: run2.output || "ingestion script exited non-zero",
-              product_area: "AI Wizard"
-            });
-          }
-          summaries.push(summaryLine);
-          ingestOutcomeMessage = outcomeMessage;
         }
+      } else {
+        const { reason, detail } = ingestFailure(ingestAttempt, executions);
+        ingestOutcomeMessage = `\u26A0\uFE0F Records were not indexed \u2014 ${reason}.${ingestCommand ? " Run the command below when you are ready." : ""}`;
+        ingestFailureDetail = detail;
+        summaries.push(
+          `\u26A0\uFE0F Ingestion did not complete: ${reason}.${detail ? `
+${detail}` : ""}`
+        );
+        logger.warn(
+          {
+            ingestCommand,
+            reason,
+            approved: ingestAttempt?.approved,
+            exitCode: ingestAttempt?.exitCode,
+            timedOut: ingestAttempt?.timedOut,
+            commandsRun: executions.length
+          },
+          "implement: ingestion script did not complete successfully"
+        );
+        track("Error", {
+          step: "Push Data",
+          error: `ingestion did not complete: ${reason}`,
+          product_area: "AI Wizard"
+        });
       }
       const commandMessages = [`Open the worktree: cd ${shellQuote(worktree)}`];
-      if (ingestRuntime && ingestEntrypoint) {
-        commandMessages.push(
-          `Ingestion command: ${buildIngestCommand(worktree, ingestRuntime, ingestEntrypoint)}`
-        );
+      if (ingestCommand) {
+        commandMessages.push(`Ingestion command: ${ingestCommand}`);
       }
       await ctx.requestUserInput({
         prompt: "",
         promptType: "enterToContinue",
         options: [],
-        messages: ingestOutcomeMessage ? [ingestOutcomeMessage, ...commandMessages] : commandMessages
+        // The wizard never streams command output, so a failed run's tail is the
+        // only place the developer sees why it failed. One message per line:
+        // the panel's height accounting counts a message as one wrapped line
+        // (see Notices.tsx), so an embedded newline overflows it.
+        messages: [
+          ingestOutcomeMessage,
+          ...ingestFailureDetail?.split("\n").filter((l) => l.trim()) ?? [],
+          ...commandMessages
+        ]
       });
     }
     if (useCases.includes("search")) {
@@ -4917,22 +4731,13 @@ ${run2.output}` : status;
         "implement: agent reported success but no files changed in the worktree"
       );
     }
-    if (installFailed) {
-      summaries.push(
-        '\u26A0\uFE0F Dependency install in the worktree failed. Run your package manager install in the worktree before the command below, or it will fail with "Cannot find module".'
-      );
-    }
     return {
       ingestionSource,
       filesChanged,
       summary: summaries.join("\n\n"),
       worktreePath: worktree,
-      ...useCases.includes("ingestion") && ingestRuntime && ingestEntrypoint ? {
-        ingestCommand: buildIngestCommand(
-          worktree,
-          ingestRuntime,
-          ingestEntrypoint
-        ),
+      ...useCases.includes("ingestion") && ingestCommand ? {
+        ingestCommand,
         ingestScriptRan,
         ...ingestRecordCount != null ? { ingestRecordCount } : {},
         ...ingestDurationMs != null ? { ingestDurationMs } : {}
@@ -4980,8 +4785,8 @@ var defaultWorkflow = {
     defineStep({
       id: "select-index",
       title: "Set up index",
-      outputSchema: z29.object({
-        selection: z29.string()
+      outputSchema: z28.object({
+        selection: z28.string()
       }),
       run: (ctx) => selectIndexStep(ctx)
     }),
@@ -5264,7 +5069,7 @@ function parseCliArgs(argv) {
 
 // src/lib/resetState.ts
 import { readdir as readdir4, rm as rm2 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join11 } from "node:path";
 var KEEP = ["wizard.log"];
 async function resetProjectState() {
   const dir = stateDir();
@@ -5278,7 +5083,7 @@ async function resetProjectState() {
   const targets = entries.filter((name) => !KEEP.includes(name));
   await Promise.all(
     targets.map(
-      (name) => rm2(join12(dir, name), { recursive: true, force: true })
+      (name) => rm2(join11(dir, name), { recursive: true, force: true })
     )
   );
   return { dir, removed: targets };

package/package.json

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