@algolia/wizard 0.9.0-rc.71.62 → 0.9.0-rc.72.60

package/dist/main.js

@@ -892,12 +892,12 @@ var sidebarItems = [
     description: "push 100 records to Algolia in seconds"
   },
   {
-    title: "detect your framework",
-    description: "React, Vue, Angular, Vanilla JS"
+    title: "detect your stack",
+    description: "React, Vue, Angular, Rails, Django, Laravel & more"
   },
   {
     title: "scaffold a search UI",
-    description: "a styled InstantSearch component, wired into your app"
+    description: "a styled InstantSearch UI, wired into your app or templates"
   },
   {
     title: "ship it",
@@ -1003,7 +1003,7 @@ var accessItems = [
   {
     tag: "READ",
     title: "Project files",
-    description: "reads package.json, configs & source to detect your stack. Read-only; nothing is uploaded."
+    description: "reads your dependency manifests (package.json\u2026), configs & source to detect your stack. Read-only; nothing is uploaded."
   },
   {
     tag: "WRITE",
@@ -2221,15 +2221,138 @@ function writeCredentialsTool(ctx) {
 // src/lib/tools/searchFiles.ts
 import { tool as tool7 } from "ai";
 import z10 from "zod";
-import { readdir as readdir2, readFile as readFile6 } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+
+// src/lib/tools/utils/packageManager.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { join as join8 } 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 readFile6(join8(cwd, "package.json"), "utf8"));
+}
+function packageManagerFrom(pkg) {
+  return pkg.packageManager?.split("@")[0] ?? "npm";
+}
+function packageManagerFromLockfile(cwd) {
+  return LOCKFILES.find(([file]) => existsSync(join8(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/shell.ts
+function shellQuote(value) {
+  return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+
+// src/lib/languages.ts
+var ENTRYPOINT_TOKEN = "{entrypoint}";
+var INGEST_DIR = ".algolia-wizard";
+var LANGUAGE_PROFILES = {
+  javascript: {
+    id: "javascript",
+    displayName: "JavaScript/TypeScript",
+    aliases: [
+      "javascript",
+      "js",
+      "typescript",
+      "ts",
+      "node",
+      "nodejs",
+      "node.js",
+      "bun",
+      "deno",
+      "ecmascript",
+      "jsx",
+      "tsx"
+    ],
+    manifests: ["package.json"],
+    // The concrete npm-family manager is resolved by detectPackageManager (it
+    // honours the package.json `packageManager` field, which lockfiles can't
+    // express), so one spec covers all four and `resolveToolchain` rewrites the
+    // binary below.
+    packageManagers: [
+      {
+        id: "npm",
+        dependency: { mode: "agent-declares", file: "package.json" },
+        installSteps: [{ argv: ["npm", "install"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["node", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".mjs", ".cjs", ".js"]
+        }
+      }
+    ],
+    sdk: { packageName: "algoliasearch", versionPin: "^5", docKey: "js" },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.mjs`,
+    // package.json scripts are repo-defined, so they're resolved at run time by
+    // repoVerification rather than listed here.
+    verification: [],
+    envReadInstruction: "Read them from `process.env`.",
+    skipDirs: ["node_modules", "dist", "build", "coverage", ".next", "out"]
+  }
+};
+var DEFAULT_LANGUAGE_ID = "javascript";
+var JAVASCRIPT = "javascript";
+var CURATED_LANGUAGES = Object.values(
+  LANGUAGE_PROFILES
+).map((profile) => profile.displayName);
+function normalizeLanguageName(name) {
+  return name.toLowerCase().trim().replace(/[\s_-]+/g, "");
+}
+var ALIAS_TO_ID = /* @__PURE__ */ new Map();
+for (const profile of Object.values(LANGUAGE_PROFILES)) {
+  for (const alias of [profile.id, profile.displayName, ...profile.aliases]) {
+    ALIAS_TO_ID.set(normalizeLanguageName(alias), profile.id);
+  }
+}
+function resolveLanguageProfile(name) {
+  const id = ALIAS_TO_ID.get(normalizeLanguageName(name));
+  return id ? LANGUAGE_PROFILES[id] : void 0;
+}
+function isSameLanguage(a, b) {
+  const x = resolveLanguageProfile(a);
+  const y = resolveLanguageProfile(b);
+  if (x && y) return x.id === y.id;
+  if (x || y) return false;
+  const folded = normalizeLanguageName(a);
+  return folded !== "" && folded === normalizeLanguageName(b);
+}
+var BASE_SKIP_DIRS = ["node_modules", ".git", "dist"];
+var ALL_SKIP_DIRS = /* @__PURE__ */ new Set([
+  ...BASE_SKIP_DIRS,
+  ...Object.values(LANGUAGE_PROFILES).flatMap((p) => p.skipDirs)
+]);
+var ALLOWED_BINARIES = new Set(
+  Object.values(LANGUAGE_PROFILES).flatMap((profile) => [
+    ...profile.packageManagers.flatMap((pm) => [
+      ...pm.installSteps.map((s) => s.argv[0]),
+      ...pm.ingest.kind === "auto" ? [pm.ingest.argv[0]] : []
+    ]),
+    ...profile.verification.map((v) => v.argv[0])
+  ])
+);
+
+// src/lib/tools/searchFiles.ts
 var MAX_QUERY_LENGTH = 1e3;
 async function walkFiles(dir) {
-  const skip = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
   const out = [];
   for (const e of await readdir2(dir, { withFileTypes: true })) {
-    if (e.name.startsWith(".") || skip.has(e.name)) continue;
-    const full = join8(dir, e.name);
+    if (e.name.startsWith(".") || ALL_SKIP_DIRS.has(e.name)) continue;
+    const full = join9(dir, e.name);
     if (e.isDirectory()) out.push(...await walkFiles(full));
     else if (e.isFile()) out.push(full);
   }
@@ -2262,7 +2385,7 @@ function searchFilesTool(ctx) {
       for (const file of await walkFiles(resolved.target)) {
         let content;
         try {
-          content = await readFile6(file, "utf8");
+          content = await readFile7(file, "utf8");
         } catch {
           continue;
         }
@@ -2286,6 +2409,10 @@ function searchFilesTool(ctx) {
 import { tool as tool8 } from "ai";
 import z11 from "zod";
 
+// src/lib/tools/repoVerification.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join10 } from "node:path";
+
 // src/lib/tools/utils/runCommand.ts
 import { spawn as spawn2 } from "node:child_process";
 var INSTALL_TIMEOUT_MS = 15 * 6e4;
@@ -2337,71 +2464,89 @@ Timed out after ${seconds}s: ${command} ${args.join(" ")}`.trim(),
   });
 }
 
-// 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() {
+async function runCheck(command, binary, args) {
+  const { code, output } = await runCommand(binary, args, {
+    timeoutMs: VERIFY_TIMEOUT_MS
+  });
+  return { command, exitCode: code, ok: code === 0, output: output.trim() };
+}
+async function javascriptChecks() {
   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 };
+    return {
+      limitation: `Could not read package.json to detect verification conventions: ${err.message}`
+    };
   }
   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 };
+    return {
+      limitation: `No verification script found in package.json (looked for: ${VERIFICATION_SCRIPT_CANDIDATES.join(", ")}).`
+    };
   }
   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], {
-      timeoutMs: VERIFY_TIMEOUT_MS
-    });
-    checks.push({ command, exitCode: code, ok: code === 0, output: output.trim() });
+    checks.push(
+      await runCheck(`${pm} run ${script}`, pm, ["run", script])
+    );
+  }
+  return { checks };
+}
+async function registryChecks(id) {
+  const profile = LANGUAGE_PROFILES[id];
+  const runnable = profile.verification.filter(
+    (spec) => !spec.requiresFile || existsSync2(join10(process.cwd(), spec.requiresFile))
+  );
+  if (runnable.length === 0) {
+    return {
+      limitation: `No mechanical verification available for ${profile.displayName} in this repo.`
+    };
   }
-  return { ok: checks.every((c) => c.ok), checks };
+  const checks = [];
+  for (const spec of runnable) {
+    checks.push(
+      await runCheck(spec.argv.join(" "), spec.argv[0], [...spec.argv.slice(1)])
+    );
+  }
+  return { checks };
+}
+async function runRepoVerificationCheck(languages = [DEFAULT_LANGUAGE_ID]) {
+  const ids = [...new Set(languages)];
+  if (ids.length === 0) ids.push(DEFAULT_LANGUAGE_ID);
+  const checks = [];
+  const limitations = [];
+  for (const id of ids) {
+    const result = id === JAVASCRIPT ? await javascriptChecks() : await registryChecks(id);
+    if ("checks" in result) checks.push(...result.checks);
+    else limitations.push(result.limitation);
+  }
+  if (checks.length === 0) {
+    return {
+      ok: false,
+      checks: [],
+      limitation: limitations.join(" ") || "No verification checks available."
+    };
+  }
+  return {
+    ok: checks.every((c) => c.ok),
+    checks,
+    ...limitations.length ? { limitation: limitations.join(" ") } : {}
+  };
 }
 
 // src/lib/tools/verifyImplementation.ts
-function verifyImplementationTool() {
+function verifyImplementationTool(ctx) {
   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.",
+    description: "Run the repo's mechanical verification checks for generated implementation changes. Uses the conventions of the repo's languages (package.json lint/typecheck/check scripts for JavaScript, the equivalent compile/analyze command elsewhere) and returns structured pass/fail evidence for the verifier to interpret.",
     inputSchema: z11.object(),
     execute: async () => {
-      logger.info("called verifyImplementation tool");
-      return runRepoVerificationCheck();
+      logger.info({ languages: ctx.languages }, "called verifyImplementation tool");
+      return runRepoVerificationCheck(ctx.languages);
     }
   });
 }
@@ -2527,12 +2672,17 @@ var DEFAULT_TOOL_LIMITS = {
   read: 20,
   match: 100
 };
-function createToolContext(limits = DEFAULT_TOOL_LIMITS, cwd = process.cwd()) {
+function createToolContext({
+  limits = DEFAULT_TOOL_LIMITS,
+  cwd = process.cwd(),
+  languages = [DEFAULT_LANGUAGE_ID]
+} = {}) {
   return {
     root: cwd,
     cwd,
     limits,
-    counts: { list: 0, search: 0, read: 0 }
+    counts: { list: 0, search: 0, read: 0 },
+    languages: languages.length ? languages : [DEFAULT_LANGUAGE_ID]
   };
 }
 
@@ -2569,7 +2719,7 @@ function createTools(ctx, { output, tools }) {
     searchFiles: withLogging("searchFiles", searchFilesTool(ctx)),
     verifyImplementation: withLogging(
       "verifyImplementation",
-      verifyImplementationTool()
+      verifyImplementationTool(ctx)
     ),
     generateRecord: withLogging("generateRecord", generateRecordTool(ctx)),
     notifyUser: withLogging("notifyUser", notifyUserTool())
@@ -2605,7 +2755,7 @@ async function runAgent(req) {
     baseURL: PROXY_BASE_URL,
     fetch: proxyFetch
   });
-  const toolContext = createToolContext();
+  const toolContext = createToolContext({ languages: req.languages });
   const readTools = ["readFile", "searchFiles", "listFiles"];
   const hasReadTools = !req.tools || req.tools.some((t) => readTools.includes(t));
   const instructions = [
@@ -2696,8 +2846,11 @@ var detectLanguageSchema = z16.object({
 var detectLanguage = () => runAgent({
   instructions: [
     "Analyze the codebase and determine the programming languages and frameworks used",
+    "Start from the dependency manifests: package.json.",
+    "List the language that owns the backend/data code first \u2014 that is the one an ingestion script will be written in.",
     "If a superset language is found, exclude the subset language. TS-over-JS.",
     "If a meta-framework is used, exclude the framework. Next-over-React.",
+    "Frameworks include backend and server-rendering frameworks (e.g. Rails, Django, Laravel, Symfony, Spring Boot, ASP.NET Core, Flask, Gin, Ktor) as well as frontend ones (React, Vue, Angular, Svelte) and mobile ones (Flutter, SwiftUI).",
     "Return the exact version",
     "Exclude things like CSS frameworks, build tools, or testing frameworks",
     'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
@@ -2795,7 +2948,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.9.0-rc.71.62",
+  version: "0.9.0-rc.72.60",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2898,82 +3051,139 @@ function parseEntries(raw) {
   return raw.split(",").map(clean).filter(Boolean).slice(0, MAX_ENTRIES).map((name) => ({ name, version: "unknown" }));
 }
 var summarize = (entries) => entries.length ? entries.map((e) => e.name).join(", ") : "none";
-async function askList(ctx, prompt, { required = false } = {}) {
+
+// src/actions/confirmLanguage.ts
+import z19 from "zod";
+var confirmLanguageSchema = z19.object({
+  languages: detectLanguageSchema.shape.languages
+});
+var OTHER_OPTION = "Other";
+function confirmed(languages) {
+  track("AI Wizard Language Confirmed", { languages });
+  return { languages };
+}
+async function askOtherLanguage(ctx) {
+  let prompt = "enter the language for your ingestion script";
   for (; ; ) {
     const answer = await ctx.requestUserInput({
       prompt,
       promptType: "textInput",
-      options: [],
-      helpText: 'Comma-separated, e.g. "TypeScript, Node".'
+      options: []
     });
     if (typeof answer !== "string") {
-      throw new Error("askList received an unexpected non-text result");
+      throw new Error("confirmLanguage received an unexpected non-text result");
     }
-    const entries = parseEntries(answer);
-    if (entries.length || !required) return entries;
-    prompt = "Please enter at least one entry:";
+    const name = parseEntries(answer)[0]?.name;
+    if (name) return name;
+    prompt = "please enter a language name:";
   }
 }
-
-// src/actions/confirmLanguage.ts
-import z19 from "zod";
-var confirmLanguageSchema = z19.object({
-  languages: detectLanguageSchema.shape.languages
-});
 async function confirmLanguage(ctx) {
   const detected = ctx.getStepOutput("project-scan");
-  const answer = await ctx.requestUserInput({
-    prompt: "Did we detect your language(s) correctly?",
-    promptType: "acceptReject",
-    options: ["Yes", "No"],
-    messages: [`Languages: ${summarize(detected.languages)}`]
-  });
-  const languages = answer === true ? detected.languages : await askList(ctx, "List the languages your project uses:", {
-    required: true
-  });
-  track("AI Wizard Language Confirmed", {
-    languages
+  const detectedLanguages = detected.languages ?? [];
+  const others = (chosen) => detectedLanguages.filter((l) => !isSameLanguage(l.name, chosen));
+  const primary = detectedLanguages[0];
+  if (primary) {
+    const accepted = await ctx.requestUserInput({
+      prompt: `Write the ingestion script in ${primary.name}?`,
+      promptType: "acceptReject",
+      options: [`Confirm ${primary.name}`, "Use a different language"],
+      secondary: [{ kind: "badge", value: "[DETECTED]" }, void 0],
+      messages: detectedLanguages.length > 1 ? [`Detected: ${summarize(detectedLanguages)}`] : []
+    });
+    if (accepted === true) return confirmed(detectedLanguages);
+  }
+  const options = [...CURATED_LANGUAGES];
+  for (const language of detectedLanguages) {
+    if (!options.some((o) => isSameLanguage(o, language.name))) {
+      options.push(language.name);
+    }
+  }
+  options.push(OTHER_OPTION);
+  const detectedFor = (option) => detectedLanguages.find((l) => isSameLanguage(option, l.name));
+  const secondary = options.map(
+    (o) => detectedFor(o) ? { kind: "badge", value: "[DETECTED]" } : void 0
+  );
+  const defaultSelectedIndex = Math.max(
+    options.findIndex((o) => detectedFor(o)),
+    0
+  );
+  const selection = await ctx.requestUserInput({
+    prompt: "select the language for your ingestion script",
+    promptType: "multipleChoice",
+    options,
+    secondary,
+    defaultSelectedIndex
   });
-  return { languages };
+  if (typeof selection !== "string") {
+    throw new Error("confirmLanguage received an unexpected non-text result");
+  }
+  const name = selection === OTHER_OPTION ? await askOtherLanguage(ctx) : selection;
+  const version = detectedFor(name)?.version ?? "unknown";
+  return confirmed([{ name, version }, ...others(name)]);
 }
 
 // src/actions/confirmFramework.ts
 import z20 from "zod";
-var confirmFrameworkSchema = z20.object({
-  frameworks: detectLanguageSchema.shape.frameworks
-});
-var CURATED_FRAMEWORKS = [
-  "Next.js",
-  "React",
-  "Vue",
-  "Angular",
-  "Svelte",
-  "Vanilla JS"
+
+// src/lib/frameworks.ts
+var BACKEND_ONLY_FRAMEWORK = "Backend only / API";
+var FRAMEWORKS = [
+  // Frontend — InstantSearch component flavors.
+  { name: "Next.js", strategy: "react", aliases: ["next", "nextjs"] },
+  { name: "React", strategy: "react", aliases: ["reactjs"] },
+  { name: "Vue", strategy: "vue", aliases: ["vuejs", "nuxt", "nuxtjs"] },
+  { name: "Angular", strategy: "angular", aliases: ["angularjs"] },
+  // No Svelte InstantSearch flavor exists, so it uses InstantSearch.js.
+  { name: "Svelte", strategy: "js", aliases: ["sveltekit"] },
+  {
+    name: "Vanilla JS",
+    strategy: "js",
+    aliases: ["vanilla", "javascript", "js", "astro", "vite"]
+  },
+  // Backend — Algolia's official framework integrations. Server-rendered
+  // templates get InstantSearch.js from a CDN.
+  {
+    name: "Rails",
+    strategy: "cdn-template",
+    aliases: ["rubyonrails", "ruby on rails", "erb"]
+  },
+  { name: "Django", strategy: "cdn-template", aliases: ["jinja", "jinja2"] },
+  { name: "Laravel", strategy: "cdn-template", aliases: ["blade"] },
+  { name: "Symfony", strategy: "cdn-template", aliases: ["twig"] },
+  // Mobile — Algolia ships InstantSearch iOS/Android and Dart clients, but the
+  // wizard can't scaffold a native UI, so it points at the docs instead.
+  { name: "Flutter", strategy: "none", aliases: [] },
+  { name: "iOS", strategy: "none", aliases: ["swiftui", "uikit"] },
+  { name: "Android", strategy: "none", aliases: ["jetpack compose", "compose"] },
+  { name: BACKEND_ONLY_FRAMEWORK, strategy: "cdn-template", aliases: [] }
 ];
-var OTHER_OPTION = "Other";
+var CURATED_FRAMEWORKS = FRAMEWORKS.map(
+  (f) => f.name
+);
 var normalize = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
-var FRAMEWORK_ALIASES = {
-  next: "nextjs",
-  nextjs: "nextjs",
-  react: "react",
-  reactjs: "react",
-  vue: "vue",
-  vuejs: "vue",
-  angular: "angular",
-  angularjs: "angular",
-  svelte: "svelte",
-  sveltekit: "svelte",
-  vanillajs: "vanillajs",
-  vanilla: "vanillajs",
-  javascript: "vanillajs",
-  js: "vanillajs"
-};
-var isSameFramework = (a, b) => {
-  const x = FRAMEWORK_ALIASES[normalize(a)] ?? normalize(a);
-  const y = FRAMEWORK_ALIASES[normalize(b)] ?? normalize(b);
+var ALIAS_TO_NAME = /* @__PURE__ */ new Map();
+for (const framework of FRAMEWORKS) {
+  for (const alias of [framework.name, ...framework.aliases]) {
+    ALIAS_TO_NAME.set(normalize(alias), framework.name);
+  }
+}
+var STRATEGY_BY_NAME = new Map(FRAMEWORKS.map((f) => [f.name, f.strategy]));
+function canonicalFrameworkName(name) {
+  return ALIAS_TO_NAME.get(normalize(name));
+}
+function isSameFramework(a, b) {
+  const x = canonicalFrameworkName(a) ?? normalize(a);
+  const y = canonicalFrameworkName(b) ?? normalize(b);
   return x !== "" && x === y;
-};
-function confirmed(name, version) {
+}
+
+// src/actions/confirmFramework.ts
+var confirmFrameworkSchema = z20.object({
+  frameworks: detectLanguageSchema.shape.frameworks
+});
+var OTHER_OPTION2 = "Other";
+function confirmed2(name, version) {
   const frameworks = [{ name, version: version ?? "unknown" }];
   track("AI Wizard Frontend Framework Confirmed", { frameworks });
   return { frameworks };
@@ -3001,7 +3211,7 @@ async function confirmFramework(ctx) {
   for (const fw of detectedFrameworks) {
     if (!options.some((o) => isSameFramework(o, fw.name))) options.push(fw.name);
   }
-  options.push(OTHER_OPTION);
+  options.push(OTHER_OPTION2);
   const detectedFor = (option) => detectedFrameworks.find((fw) => isSameFramework(option, fw.name));
   const primary = detectedFrameworks[0];
   if (primary) {
@@ -3011,7 +3221,7 @@ async function confirmFramework(ctx) {
       options: [`Confirm ${primary.name}`, "Use a different framework"],
       secondary: [{ kind: "badge", value: "[DETECTED]" }, void 0]
     });
-    if (accepted === true) return confirmed(primary.name, primary.version);
+    if (accepted === true) return confirmed2(primary.name, primary.version);
   }
   const secondary = options.map(
     (o) => detectedFor(o) ? { kind: "badge", value: "[DETECTED]" } : void 0
@@ -3021,7 +3231,7 @@ async function confirmFramework(ctx) {
     0
   );
   const selection = await ctx.requestUserInput({
-    prompt: "select a framework",
+    prompt: "select the framework that renders your UI",
     promptType: "multipleChoice",
     options,
     secondary,
@@ -3030,10 +3240,10 @@ async function confirmFramework(ctx) {
   if (typeof selection !== "string") {
     throw new Error("confirmFramework received an unexpected non-text result");
   }
-  if (selection === OTHER_OPTION) {
-    return confirmed(await askOtherFramework(ctx));
+  if (selection === OTHER_OPTION2) {
+    return confirmed2(await askOtherFramework(ctx));
   }
-  return confirmed(selection, detectedFor(selection)?.version);
+  return confirmed2(selection, detectedFor(selection)?.version);
 }
 
 // src/actions/promptUser.ts
@@ -3126,15 +3336,15 @@ async function confirmEntities(ctx) {
     onSubmit: () => {
     }
   });
-  const confirmed2 = typeof selection === "string" ? entities.filter((e) => e.name === selection) : [];
-  if (confirmed2.length === 0) {
+  const confirmed3 = typeof selection === "string" ? entities.filter((e) => e.name === selection) : [];
+  if (confirmed3.length === 0) {
     throw new Error("User cancelled entity selection \u2014 analysis halted.");
   }
-  ctx.setUserInput("confirmedEntities", confirmed2);
+  ctx.setUserInput("confirmedEntities", confirmed3);
   track("AI Wizard Entities Confirmed", {
-    entities: toEntitySummary(confirmed2)
+    entities: toEntitySummary(confirmed3)
   });
-  return { ingestionAnalysis: entities, confirmedEntities: confirmed2 };
+  return { ingestionAnalysis: entities, confirmedEntities: confirmed3 };
 }
 
 // src/actions/review.ts
@@ -3206,7 +3416,7 @@ import {
   basename as basename2,
   dirname as dirname7,
   isAbsolute as isAbsolute2,
-  join as join10,
+  join as join11,
   relative as relative2,
   resolve as resolve3
 } from "node:path";
@@ -3240,7 +3450,7 @@ async function isWorkingTreeDirty(repoRoot) {
   return out.trim().length > 0;
 }
 async function pruneOldWorktrees(repoRoot) {
-  const dir = join10(stateDir(repoRoot), "worktrees");
+  const dir = join11(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);
@@ -3251,7 +3461,7 @@ async function pruneOldWorktrees(repoRoot) {
         "worktree",
         "remove",
         "--force",
-        join10(dir, slug)
+        join11(dir, slug)
       ]);
       await git(["-C", repoRoot, "branch", "-D", branch]);
     } catch (err) {
@@ -3265,7 +3475,7 @@ 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 = join11(stateDir(repoRoot), "worktrees", dirSlug);
   await git(["-C", repoRoot, "worktree", "prune"]);
   await pruneOldWorktrees(repoRoot);
   await mkdir6(dirname7(path), { recursive: true });
@@ -3385,8 +3595,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 = join11(ingestDir, basename2(source));
+  const dest = join11(worktreePath, relPath);
   try {
     await mkdir6(dirname7(dest), { recursive: true });
     await copyFile(source, dest);
@@ -3402,7 +3612,7 @@ function hasEnvVar(content, name) {
   return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
 }
 async function writeSearchEnvValues(worktreePath, vars) {
-  const target = join10(worktreePath, ".env");
+  const target = join11(worktreePath, ".env");
   let existing = "";
   try {
     existing = await readFile8(target, "utf8");
@@ -3522,15 +3732,15 @@ async function resolveSearchOnlyKey(index) {
 }
 
 // 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 as existsSync3 } from "node:fs";
+import { dirname as dirname8, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var DOCS_SUBPATH = join11("docs", "algolia-sdk");
+var DOCS_SUBPATH = join12("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 = join12(dir, DOCS_SUBPATH);
+    if (existsSync3(candidate)) return candidate;
     const parent = dirname8(dir);
     if (parent === dir) return void 0;
     dir = parent;
@@ -3552,7 +3762,7 @@ function loadAlgoliaDoc(language) {
     );
     return "";
   }
-  return readFileSync(join11(docsDir, files[0]), "utf8").trim();
+  return readFileSync(join12(docsDir, files[0]), "utf8").trim();
 }
 function getNamedDoc(name, language) {
   const docsDir = findDocsDir();
@@ -3560,8 +3770,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 = join12(docsDir, `${name}-${language}.md`);
+  if (!existsSync3(file)) {
     logger.warn({ name, language }, "named SDK reference not found");
     return "";
   }
@@ -3581,11 +3791,6 @@ function getFrameworkSpecificDoc(frameworks) {
   return loadAlgoliaDoc("js");
 }
 
-// src/lib/shell.ts
-function shellQuote(value) {
-  return "'" + value.replace(/'/g, "'\\''") + "'";
-}
-
 // src/actions/implement.ts
 var implementSchema = z24.object({
   filesChanged: z24.array(z24.string()),
@@ -3634,7 +3839,7 @@ var verificationOutputSchema = z24.object({
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
-var INGEST_DIR = ".algolia-wizard";
+var INGEST_DIR2 = ".algolia-wizard";
 function detectUiFramework(language) {
   const names = language.frameworks.map((f) => f.name.toLowerCase());
   if (names.some((n) => n.includes("vue") || n.includes("nuxt"))) return "Vue";
@@ -3898,7 +4103,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     await confirmDirtyWorkingTree(ctx, repoRoot);
   }
   const normalized = normalizeFindingPaths(findings);
-  const confirmed2 = normalized.confirmedEntities;
+  const confirmed3 = normalized.confirmedEntities;
   const searchLocation = normalized.searchImplementationAnalysis;
   let appId;
   let searchKey;
@@ -3922,7 +4127,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       const copied = await copyUploadIntoWorktree(
         repoRoot,
         worktree,
-        INGEST_DIR,
+        INGEST_DIR2,
         uploadSourcePath ?? ""
       );
       if (copied.ok) {
@@ -3938,14 +4143,14 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     }
     const input = {
       findings: normalized,
-      confirmed: confirmed2,
+      confirmed: confirmed3,
       searchLocation,
       targetIndex,
       language,
       appId,
       searchKey,
       searchEnvVars: searchEnvVars(language, appId, searchKey),
-      ingestDir: INGEST_DIR,
+      ingestDir: INGEST_DIR2,
       ingestionSource,
       uploadFilePath,
       // language.frameworks already prefers the confirm-framework step output,
@@ -4037,7 +4242,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
             ingestRecordCount = parseIngestRecordCount(run2.output);
             if (ingestRecordCount != null) {
               track("AI Wizard Ingest Successful", {
-                entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
+                entity_name: confirmed3?.map((e) => e.name).join(", ") || "unknown",
                 record_count: ingestRecordCount,
                 duration_ms: ingestDurationMs
               });
@@ -4518,7 +4723,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 join13 } from "node:path";
 var KEEP = ["wizard.log"];
 async function resetProjectState() {
   const dir = stateDir();
@@ -4530,7 +4735,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 }))
+    targets.map((name) => rm2(join13(dir, name), { recursive: true, force: true }))
   );
   return { dir, removed: targets };
 }

package/package.json

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