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

package/dist/main.js

@@ -2221,7 +2221,12 @@ function writeCredentialsTool(ctx) {
 // src/lib/tools/searchFiles.ts
 import { tool as tool7 } from "ai";
 import z10 from "zod";
+import { readdir as readdir3, readFile as readFile8 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+
+// src/lib/languages.ts
 import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
 import { join as join9 } from "node:path";
 
 // src/lib/tools/utils/packageManager.ts
@@ -2310,6 +2315,9 @@ var JAVASCRIPT = "javascript";
 var CURATED_LANGUAGES = Object.values(
   LANGUAGE_PROFILES
 ).map((profile) => profile.displayName);
+function isBackendLanguage(profile) {
+  return profile.id !== JAVASCRIPT;
+}
 function normalizeLanguageName(name) {
   return name.toLowerCase().trim().replace(/[\s_-]+/g, "");
 }
@@ -2345,14 +2353,150 @@ var ALLOWED_BINARIES = new Set(
     ...profile.verification.map((v) => v.argv[0])
   ])
 );
+var JS_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
+function isWorktreeRelativeCommand(command) {
+  return command.includes("/");
+}
+function withCommand(argv, command) {
+  return [command, ...argv.slice(1)];
+}
+function resolveDeclaredManifest(root, packageManager) {
+  const { dependency } = packageManager;
+  if (dependency.mode !== "agent-declares" || !dependency.alternatives?.length) {
+    return packageManager;
+  }
+  const present = [dependency.file, ...dependency.alternatives].find(
+    (file) => existsSync2(join9(root, file))
+  );
+  if (!present || present === dependency.file) return packageManager;
+  return { ...packageManager, dependency: { ...dependency, file: present } };
+}
+async function manifestPresent(root, manifest, listing) {
+  if (!manifest.startsWith("*.")) return existsSync2(join9(root, manifest));
+  if (!listing.entries) {
+    const entries = await readdir2(root).catch(() => []);
+    listing.entries = Array.isArray(entries) ? entries : [];
+  }
+  const suffix = manifest.slice(1);
+  return listing.entries.some((e) => e.endsWith(suffix));
+}
+async function profileManifestPresent(root, profile, listing) {
+  for (const manifest of profile.manifests) {
+    if (await manifestPresent(root, manifest, listing)) return true;
+  }
+  return false;
+}
+async function detectProfilesFromManifests(root) {
+  const listing = {};
+  const found = [];
+  for (const profile of Object.values(LANGUAGE_PROFILES)) {
+    if (await profileManifestPresent(root, profile, listing)) found.push(profile);
+  }
+  return found;
+}
+async function hasProfileManifest(root, profile) {
+  return profileManifestPresent(root, profile, {});
+}
+async function pickIngestionCandidates(root, confirmedNames) {
+  const confirmed3 = confirmedNames.map((name) => resolveLanguageProfile(name)).filter((p) => p !== void 0);
+  const onDisk = await detectProfilesFromManifests(root);
+  const onDiskIds = new Set(onDisk.map((p) => p.id));
+  const candidates = [
+    ...new Map(
+      confirmed3.filter((p) => onDiskIds.has(p.id)).map((p) => [p.id, p])
+    ).values()
+  ];
+  return { candidates, confirmed: confirmed3, onDisk };
+}
+async function resolveToolchain(root, profile) {
+  const signals = (pm) => [
+    ...pm.lockfiles ?? [],
+    ...pm.detectFiles ?? []
+  ];
+  const matched = profile.packageManagers.find(
+    (pm) => signals(pm).some((f) => existsSync2(join9(root, f)))
+  );
+  const fallback = profile.packageManagers.find((pm) => signals(pm).length === 0) ?? profile.packageManagers[0];
+  const packageManager = resolveDeclaredManifest(root, matched ?? fallback);
+  let { installSteps, ingest } = packageManager;
+  installSteps = installSteps.map(
+    (step) => isWorktreeRelativeCommand(step.argv[0]) ? { ...step, argv: withCommand(step.argv, join9(root, step.argv[0])) } : step
+  );
+  if (ingest.kind === "auto" && isWorktreeRelativeCommand(ingest.argv[0])) {
+    ingest = {
+      ...ingest,
+      argv: withCommand(ingest.argv, join9(root, ingest.argv[0]))
+    };
+  }
+  if (profile.id === "javascript") {
+    const pm = await detectPackageManager(root);
+    if (JS_PACKAGE_MANAGERS.has(pm)) {
+      installSteps = installSteps.map((step) => ({
+        ...step,
+        argv: withCommand(step.argv, pm)
+      }));
+      if (pm === "bun" && ingest.kind === "auto") {
+        ingest = { ...ingest, argv: withCommand(ingest.argv, "bun") };
+      }
+    }
+  }
+  return { profile, packageManager, installSteps, ingest };
+}
+function resolveIngestArgv(ingest, entrypoint) {
+  if (ingest.kind !== "auto") {
+    throw new Error("resolveIngestArgv called for a manual-run toolchain");
+  }
+  return ingest.argv.map(
+    (part) => part === ENTRYPOINT_TOKEN ? entrypoint : part
+  );
+}
+function describeIngestCommand(ingest, entrypoint) {
+  if (ingest.kind !== "auto") return ingest.runCommand;
+  return ingest.argv.map((part) => part === ENTRYPOINT_TOKEN ? shellQuote(entrypoint) : part).join(" ");
+}
+function ingestScriptDir(profile) {
+  const parts = profile.ingestEntrypointExample.split("/");
+  return parts.slice(0, -1).join("/") || ".";
+}
+function localSourceLimitation(root, profile) {
+  const caveat = profile.localSourceCaveat;
+  if (!caveat) return void 0;
+  return existsSync2(join9(root, caveat.unless)) ? void 0 : caveat.message;
+}
+async function missingBuildTask(root, toolchain) {
+  const { ingest, packageManager } = toolchain;
+  if (ingest.kind !== "manual" || !ingest.requiresBuildTask) return void 0;
+  if (packageManager.dependency.mode !== "agent-declares") return void 0;
+  const buildFile = join9(root, packageManager.dependency.file);
+  const contents = await readFile7(buildFile, "utf8").catch(() => void 0);
+  if (contents === void 0) return void 0;
+  return contents.includes(ingest.requiresBuildTask) ? void 0 : ingest.requiresBuildTask;
+}
+function sdkVersionPin(profile, packageManager) {
+  return packageManager.sdkVersionPin ?? profile.sdk.versionPin;
+}
+function dependencyInstruction(toolchain) {
+  const { profile, packageManager } = toolchain;
+  const { packageName } = profile.sdk;
+  const versionPin = sdkVersionPin(profile, packageManager);
+  const also = profile.sdk.alsoRequires ? ` ${profile.sdk.alsoRequires}` : "";
+  switch (packageManager.dependency.mode) {
+    case "wizard-installs":
+      return `The wizard installs ${packageName} ${versionPin} in the worktree after you finish \u2014 import it directly and do not edit dependency manifests for it.${also}`;
+    case "code-imports":
+      return `Import ${packageName} in the script; the wizard resolves and fetches it in the worktree after you finish. Do not edit dependency manifests by hand.${also}`;
+    case "agent-declares":
+      return `Declare ${packageName} ${versionPin} in "${packageManager.dependency.file}" (create the file if needed), plus any other dependency your script imports; the wizard installs them in the worktree after you finish.${also}`;
+  }
+}
 
 // src/lib/tools/searchFiles.ts
 var MAX_QUERY_LENGTH = 1e3;
 async function walkFiles(dir) {
   const out = [];
-  for (const e of await readdir2(dir, { withFileTypes: true })) {
+  for (const e of await readdir3(dir, { withFileTypes: true })) {
     if (e.name.startsWith(".") || ALL_SKIP_DIRS.has(e.name)) continue;
-    const full = join9(dir, e.name);
+    const full = join10(dir, e.name);
     if (e.isDirectory()) out.push(...await walkFiles(full));
     else if (e.isFile()) out.push(full);
   }
@@ -2385,7 +2529,7 @@ function searchFilesTool(ctx) {
       for (const file of await walkFiles(resolved.target)) {
         let content;
         try {
-          content = await readFile7(file, "utf8");
+          content = await readFile8(file, "utf8");
         } catch {
           continue;
         }
@@ -2410,8 +2554,8 @@ 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";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join11 } from "node:path";
 
 // src/lib/tools/utils/runCommand.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -2500,7 +2644,7 @@ async function javascriptChecks() {
 async function registryChecks(id) {
   const profile = LANGUAGE_PROFILES[id];
   const runnable = profile.verification.filter(
-    (spec) => !spec.requiresFile || existsSync2(join10(process.cwd(), spec.requiresFile))
+    (spec) => !spec.requiresFile || existsSync3(join11(process.cwd(), spec.requiresFile))
   );
   if (runnable.length === 0) {
     return {
@@ -2899,6 +3043,7 @@ var MODE_CONFIG = {
       "Analyze the codebase to find the data entities (models) that should be ingested into Algolia.",
       "For each entity, return its name, the file path(s) where it is defined, and its indexable attribute keys (the fields a user would search or filter on).",
       "Inspect the source of each entity to extract real field names for attributes \u2014 do not guess or leave attributes empty.",
+      "Entities live wherever the stack keeps them: TypeScript interfaces or a Prisma schema.",
       "Prefer domain models (e.g. Document, Product, User) over framework or infrastructure types.",
       "Use as few tools as possible, but do not guess. If you cannot find any entities, return an empty array.",
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
@@ -2910,8 +3055,9 @@ var MODE_CONFIG = {
     instructions: [
       "Analyze the codebase to determine the single best location to add search UI functionality.",
       "Prefer a shared, always-rendered layout location (e.g. a header or navigation component) so search is reachable across the app.",
-      "Return one file path as searchImplementationAnalysis (e.g. /layouts/header.tsx).",
-      'Use as few tools as possible, but do not guess. If you cannot find a clear location, say "unknown".',
+      "It may be a client-side component or a server-rendered template \u2014 return whichever the project actually renders its UI from (e.g. /layouts/header.tsx, app/views/layouts/application.html.erb, templates/base.html, resources/views/layouts/app.blade.php, templates/base.html.twig).",
+      "Return one file path as searchImplementationAnalysis.",
+      'Use as few tools as possible, but do not guess. If the project renders no UI at all (an API-only service), say "unknown".',
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
       "When done, call reportStatus"
     ],
@@ -2920,7 +3066,7 @@ var MODE_CONFIG = {
   verification: {
     instructions: [
       "Analyze the codebase to determine which code-quality tools are available to validate changes.",
-      "Look at package.json scripts, config files (e.g. .eslintrc, tsconfig, prettier), and dev dependencies.",
+      "Look at the dependency manifest and config files for the project's languages: package.json scripts with tsconfig/eslint/prettier.",
       'Return the tool names as an array, e.g. ["eslint", "prettier", "tsc"].',
       "Use as few tools as possible, but do not guess. If you cannot find any, return an empty array.",
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
@@ -2948,7 +3094,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.9.0-rc.72.60",
+  version: "0.9.0-rc.74.64",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2970,7 +3116,7 @@ var package_default = {
     prepare: "husky",
     prepublishOnly: "pnpm build",
     reset: "tsx ./scripts/reset-state.ts",
-    "test:fixtures": "touch .env && tsx --env-file=.env ./fixtures/run-fixtures.ts",
+    "test:toolchains": "tsx ./scripts/verify-toolchains.ts",
     "test:tools": "tsx ./tool-evals/toolEval.ts",
     test: "vitest",
     typecheck: "tsc --noEmit -p tsconfig.json"
@@ -3177,6 +3323,52 @@ function isSameFramework(a, b) {
   const y = canonicalFrameworkName(b) ?? normalize(b);
   return x !== "" && x === y;
 }
+function resolveSearchStrategy(frameworkName, hasJavaScriptInStack) {
+  const canonical = frameworkName ? canonicalFrameworkName(frameworkName) : void 0;
+  const strategy = canonical ? STRATEGY_BY_NAME.get(canonical) : void 0;
+  if (strategy) return strategy;
+  return hasJavaScriptInStack ? "js" : "cdn-template";
+}
+function searchDocKey(strategy) {
+  return strategy === "cdn-template" ? "templates" : strategy;
+}
+function bundlesJavaScript(strategy) {
+  return strategy !== "cdn-template" && strategy !== "none";
+}
+function canScaffoldSearchUI(strategy) {
+  return strategy !== "none";
+}
+var ENV_PREFIXES = [
+  { aliases: ["next", "nextjs"], prefix: "NEXT_PUBLIC_" },
+  { aliases: ["nuxt", "nuxtjs"], prefix: "NUXT_PUBLIC_" },
+  { aliases: ["astro"], prefix: "PUBLIC_" },
+  { aliases: ["vite"], prefix: "VITE_" }
+];
+var DEFAULT_ENV_PREFIX = "PUBLIC_";
+function publicEnvPrefix(frameworkNames, strategy) {
+  if (!bundlesJavaScript(strategy)) return "";
+  const present = new Set(frameworkNames.map(normalize));
+  for (const { aliases, prefix } of ENV_PREFIXES) {
+    if (aliases.some((alias) => present.has(alias))) return prefix;
+  }
+  return DEFAULT_ENV_PREFIX;
+}
+function describeSearchTarget(strategy, frameworkName) {
+  switch (strategy) {
+    case "react":
+      return "React (react-instantsearch)";
+    case "vue":
+      return "Vue (vue-instantsearch)";
+    case "angular":
+      return "Angular (angular-instantsearch)";
+    case "js":
+      return "plain JavaScript (InstantSearch.js)";
+    case "cdn-template":
+      return `${frameworkName ?? "server-rendered"} templates (InstantSearch.js via CDN)`;
+    case "none":
+      return frameworkName ?? "a native mobile app";
+  }
+}
 
 // src/actions/confirmFramework.ts
 var confirmFrameworkSchema = z20.object({
@@ -3368,7 +3560,7 @@ ${JSON.stringify(s.output, null, 2)}`
 }
 function formatReviewSummary(result) {
   const nextStepLines = result.nextSteps.map((step) => {
-    const isIngestCommand = step.includes(".algolia-wizard/ingest.sh");
+    const isIngestCommand = step.includes("algolia-wizard/");
     const isWorktreeCommand = step.includes("/worktrees/");
     return {
       text: `\u2192 ${step}`,
@@ -3410,13 +3602,14 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 import z24 from "zod";
 
 // src/lib/worktree.ts
-import { execFile, spawn as spawn3 } 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 { execFile } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { copyFile, mkdir as mkdir6, readdir as readdir4, readFile as readFile9, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
 import {
   basename as basename2,
   dirname as dirname7,
   isAbsolute as isAbsolute2,
-  join as join11,
+  join as join12,
   relative as relative2,
   resolve as resolve3
 } from "node:path";
@@ -3450,8 +3643,8 @@ async function isWorkingTreeDirty(repoRoot) {
   return out.trim().length > 0;
 }
 async function pruneOldWorktrees(repoRoot) {
-  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);
+  const dir = join12(stateDir(repoRoot), "worktrees");
+  const stale = (await readdir4(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);
     try {
@@ -3461,7 +3654,7 @@ async function pruneOldWorktrees(repoRoot) {
         "worktree",
         "remove",
         "--force",
-        join11(dir, slug)
+        join12(dir, slug)
       ]);
       await git(["-C", repoRoot, "branch", "-D", branch]);
     } catch (err) {
@@ -3475,43 +3668,55 @@ async function pruneOldWorktrees(repoRoot) {
 async function createWorktree(repoRoot) {
   const branch = `${WIZARD_BRANCH_PREFIX}${Date.now()}`;
   const dirSlug = branch.replace(/\//g, "-");
-  const path = join11(stateDir(repoRoot), "worktrees", dirSlug);
+  const path = join12(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 = spawn3(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() })
-    );
+async function spawnStep(worktreePath, argv) {
+  const { code, output } = await runCommand(argv[0], [...argv.slice(1)], {
+    cwd: worktreePath,
+    timeoutMs: INSTALL_TIMEOUT_MS
   });
+  return { ok: code === 0, output: output.trim() };
+}
+async function installWorktreeDeps(worktreePath, toolchain) {
+  const { profile, installSteps, packageManager } = toolchain;
+  const declared = packageManager.dependency.mode === "agent-declares" ? packageManager.dependency.file : void 0;
+  const haveSomethingToInstall = await hasProfileManifest(worktreePath, profile) || declared !== void 0 && existsSync4(join12(worktreePath, declared));
+  if (!haveSomethingToInstall) {
+    return {
+      ok: true,
+      output: `no ${profile.displayName} manifest; skipped install`
+    };
+  }
+  if (installSteps.length === 0) {
+    return {
+      ok: true,
+      output: `${profile.displayName} (${toolchain.packageManager.id}) has no wizard-run install step`
+    };
+  }
+  const outputs = [];
+  for (const step of installSteps) {
+    if (step.requiresFile && !existsSync4(join12(worktreePath, step.requiresFile)))
+      continue;
+    const result = await spawnStep(worktreePath, step.argv);
+    if (result.output) outputs.push(result.output);
+    if (result.ok) continue;
+    if (step.optional) {
+      logger.warn(
+        { step: step.argv.join(" "), output: result.output },
+        "installWorktreeDeps: optional install step failed; continuing"
+      );
+      continue;
+    }
+    return { ok: false, output: outputs.join("\n").trim() };
+  }
+  return { ok: true, output: outputs.join("\n").trim() };
 }
-var INGEST_RUNTIMES = ["node", "python", "python3", "bun"];
-function validateIngestEntrypoint(worktreePath, entrypoint) {
+function validateIngestEntrypoint(worktreePath, entrypoint, allowedExtensions) {
   if (!entrypoint || entrypoint.startsWith("-")) {
     return {
       ok: false,
@@ -3526,18 +3731,29 @@ function validateIngestEntrypoint(worktreePath, entrypoint) {
       reason: `entrypoint "${entrypoint}" resolves outside the worktree`
     };
   }
+  if (allowedExtensions?.length && !allowedExtensions.some((ext) => entrypoint.endsWith(ext))) {
+    return {
+      ok: false,
+      reason: `entrypoint "${entrypoint}" is not one of ${allowedExtensions.join(", ")}`
+    };
+  }
   return { ok: true, target };
 }
-async function runIngestScript(worktreePath, runtime, entrypoint, env = {}) {
-  if (!INGEST_RUNTIMES.includes(runtime)) {
+async function runIngestScript(worktreePath, toolchain, entrypoint, env = {}) {
+  const { ingest, profile, packageManager } = toolchain;
+  if (ingest.kind !== "auto") {
     return {
       ran: false,
       ok: false,
       output: "",
-      reason: `runtime "${runtime}" is not an allowed interpreter (${INGEST_RUNTIMES.join(", ")})`
+      reason: `${profile.displayName} (${packageManager.id}) projects must be run manually: ${ingest.runCommand}`
     };
   }
-  const validated = validateIngestEntrypoint(worktreePath, entrypoint);
+  const validated = validateIngestEntrypoint(
+    worktreePath,
+    entrypoint,
+    ingest.entrypointExtensions
+  );
   if (!validated.ok) {
     return { ran: false, ok: false, output: "", reason: validated.reason };
   }
@@ -3558,29 +3774,13 @@ async function runIngestScript(worktreePath, runtime, entrypoint, env = {}) {
       reason: `entrypoint "${entrypoint}" does not exist`
     };
   }
-  return new Promise((resolveRun) => {
-    let output = "";
-    const child = spawn3(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() })
-    );
+  const argv = resolveIngestArgv(ingest, entrypoint);
+  const { code, output } = await runCommand(argv[0], argv.slice(1), {
+    cwd: worktreePath,
+    env,
+    timeoutMs: INGEST_TIMEOUT_MS
   });
+  return { ran: true, ok: code === 0, output: output.trim() };
 }
 async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourcePath) {
   const trimmed = sourcePath.trim();
@@ -3595,8 +3795,8 @@ async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourceP
   } catch {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
-  const relPath = join11(ingestDir, basename2(source));
-  const dest = join11(worktreePath, relPath);
+  const relPath = join12(ingestDir, basename2(source));
+  const dest = join12(worktreePath, relPath);
   try {
     await mkdir6(dirname7(dest), { recursive: true });
     await copyFile(source, dest);
@@ -3612,10 +3812,10 @@ function hasEnvVar(content, name) {
   return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
 }
 async function writeSearchEnvValues(worktreePath, vars) {
-  const target = join11(worktreePath, ".env");
+  const target = join12(worktreePath, ".env");
   let existing = "";
   try {
-    existing = await readFile8(target, "utf8");
+    existing = await readFile9(target, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -3732,64 +3932,33 @@ async function resolveSearchOnlyKey(index) {
 }
 
 // src/lib/algoliaDocs.ts
-import { readFileSync, readdirSync, existsSync as existsSync3 } from "node:fs";
-import { dirname as dirname8, join as join12 } from "node:path";
+import { readFileSync, existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname8, join as join13 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var DOCS_SUBPATH = join12("docs", "algolia-sdk");
+var DOCS_SUBPATH = join13("docs", "algolia-sdk");
 function findDocsDir() {
   let dir = dirname8(fileURLToPath2(import.meta.url));
   for (; ; ) {
-    const candidate = join12(dir, DOCS_SUBPATH);
-    if (existsSync3(candidate)) return candidate;
+    const candidate = join13(dir, DOCS_SUBPATH);
+    if (existsSync5(candidate)) return candidate;
     const parent = dirname8(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
-function loadAlgoliaDoc(language) {
-  const docsDir = findDocsDir();
-  if (!docsDir) {
-    logger.warn(
-      "algoliaDocs: docs/algolia-sdk not found; skipping SDK reference"
-    );
-    return "";
-  }
-  const files = readdirSync(docsDir).filter((f) => f.includes(language));
-  if (files.length === 0) {
-    logger.warn(
-      { language },
-      "algoliaDocs: no SDK reference found for language; skipping"
-    );
-    return "";
-  }
-  return readFileSync(join12(docsDir, files[0]), "utf8").trim();
-}
-function getNamedDoc(name, language) {
+function getNamedDoc(name, key) {
   const docsDir = findDocsDir();
   if (!docsDir) {
     logger.warn("docs/algolia-sdk not found");
     return "";
   }
-  const file = join12(docsDir, `${name}-${language}.md`);
-  if (!existsSync3(file)) {
-    logger.warn({ name, language }, "named SDK reference not found");
+  const file = join13(docsDir, `${name}-${key}.md`);
+  if (!existsSync5(file)) {
+    logger.warn({ name, key }, "named SDK reference not found");
     return "";
   }
   return readFileSync(file, "utf8").trim();
 }
-function getFrameworkSpecificDoc(frameworks) {
-  const fw = frameworks.map((f) => f.toLowerCase());
-  if (fw.includes("vue") || fw.includes("nuxt")) {
-    return loadAlgoliaDoc("vue");
-  }
-  if (fw.includes("react") || fw.includes("next.js")) {
-    return loadAlgoliaDoc("react");
-  }
-  if (fw.includes("angular")) {
-    return loadAlgoliaDoc("angular");
-  }
-  return loadAlgoliaDoc("js");
-}
 
 // src/actions/implement.ts
 var implementSchema = z24.object({
@@ -3824,12 +3993,11 @@ var implementSchema = z24.object({
 });
 var implementationOutputSchema = z24.object({
   summary: z24.string(),
-  // Ingestion only: how to run the generated script, as a structured pair the
-  // wizard turns into an argv (`<runtime> <entrypoint>`) — never a free-form
-  // command string. `runtime` is constrained to an allowlisted interpreter and
-  // `entrypoint` is validated to a worktree-relative path before execution, so
-  // the agent cannot inject extra commands or swap the interpreter.
-  runtime: z24.enum(INGEST_RUNTIMES).optional(),
+  // Ingestion only: the script the wizard should run, as a bare path — never a
+  // command string, and never the interpreter. The command comes from the
+  // resolved language toolchain (a registry constant); this path is validated to
+  // a worktree-relative file with a runnable extension and substituted into it.
+  // So the agent contributes no part of the command that gets executed.
   entrypoint: z24.string().optional()
 });
 var verificationOutputSchema = z24.object({
@@ -3839,47 +4007,11 @@ var verificationOutputSchema = z24.object({
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
-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";
-  if (names.some((n) => n.includes("react") || n.includes("next")))
-    return "React";
-  if (names.some((n) => n.includes("angular"))) return "Angular";
-  return "JavaScript";
-}
-function frameworksForDoc(framework) {
-  switch (framework) {
-    case "React":
-      return ["react"];
-    case "Vue":
-      return ["vue"];
-    case "Angular":
-      return ["angular"];
-    case "JavaScript":
-      return [];
-  }
-}
-function publicEnvPrefix(language) {
-  const frameworkNames = language.frameworks.map(
-    (framework) => framework.name.toLowerCase()
+function buildSearchEnvVars(language, strategy, appId, searchKey) {
+  const prefix = publicEnvPrefix(
+    language.frameworks.map((framework) => framework.name),
+    strategy
   );
-  if (frameworkNames.some((name) => name.includes("next"))) {
-    return "NEXT_PUBLIC_";
-  }
-  if (frameworkNames.some((name) => name.includes("nuxt"))) {
-    return "NUXT_PUBLIC_";
-  }
-  if (frameworkNames.some((name) => name.includes("astro"))) {
-    return "PUBLIC_";
-  }
-  if (frameworkNames.some((name) => name.includes("vite"))) {
-    return "VITE_";
-  }
-  return "PUBLIC_";
-}
-function searchEnvVars(language, appId, searchKey) {
-  const prefix = publicEnvPrefix(language);
   return [
     {
       name: `${prefix}ALGOLIA_APP_ID`,
@@ -3891,6 +4023,38 @@ function searchEnvVars(language, appId, searchKey) {
     }
   ];
 }
+async function resolveIngestionProfile(ctx, language, repoRoot) {
+  const { candidates, confirmed: confirmed3, onDisk } = await pickIngestionCandidates(
+    repoRoot,
+    language.languages.map((l) => l.name)
+  );
+  if (candidates.length === 0) {
+    const chosen = confirmed3[0] ?? onDisk[0] ?? LANGUAGE_PROFILES[DEFAULT_LANGUAGE_ID];
+    logger.warn(
+      {
+        confirmed: language.languages.map((l) => l.name),
+        onDisk: onDisk.map((p) => p.id),
+        chosen: chosen.id
+      },
+      "implement: no confirmed language matched a manifest on disk; falling back"
+    );
+    return chosen;
+  }
+  if (candidates.length === 1) return candidates[0];
+  const backends = candidates.filter(isBackendLanguage);
+  if (backends.length === 1) return backends[0];
+  if (backends.length === 0) return candidates[0];
+  if (isBackendLanguage(candidates[0])) return candidates[0];
+  const options = backends.map((p) => p.displayName);
+  const selection = await ctx.requestUserInput({
+    prompt: "Which language should the ingestion script use?",
+    promptType: "multipleChoice",
+    options,
+    defaultSelectedIndex: 0
+  });
+  const picked = typeof selection === "string" ? backends.find((p) => p.displayName === selection) : void 0;
+  return picked ?? backends[0];
+}
 function baseInstructions(input) {
   return [
     `Target Algolia index: ${input.targetIndex}`,
@@ -3918,37 +4082,48 @@ function sourceSpecificInstructions(input) {
     generated: [
       "No real data source exists; use sample records for each confirmed entity.",
       "Call the generateRecord tool once per entity (entityName, attributes, count 20-50); it invents the values and unique objectIDs and writes them to a JSON file in the worktree, returning the file path. Do not write records or objectIDs yourself.",
-      "In the script, read and parse each returned file path at runtime (e.g. JSON.parse(readFileSync(...)) in Node/Bun, json.load(open(...)) in Python) instead of inlining the records as literals.",
+      "In the script, read and parse each returned JSON file path at runtime using the idiomatic file read for the language you are writing in (the SDK reference above shows one) instead of inlining the records as literals.",
       "Add a prominent TODO where the developer swaps the generated records (and the JSON file under `.algolia-wizard/data/`) for their real record source."
     ]
   };
   return byLine[input.ingestionSource];
 }
 function ingestionInstructions(input) {
+  const { ingestionProfile: profile, toolchain } = input;
+  const { ingest } = toolchain;
+  const extensions = ingest.entrypointExtensions.join(", ");
+  const runInstruction = ingest.kind === "auto" ? `Return "entrypoint": the script path relative to the worktree root (e.g. "${profile.ingestEntrypointExample}"), ending in one of ${extensions}. The wizard runs it with \`${describeIngestCommand(ingest, profile.ingestEntrypointExample)}\`, so it must be a plain path with no flags or arguments and must run as-is under that command.` : `Return "entrypoint": the script path relative to the worktree root (e.g. "${profile.ingestEntrypointExample}"), ending in one of ${extensions}. The wizard does NOT run ${profile.displayName} ${toolchain.packageManager.id} projects itself \u2014 it tells the developer to run \`${describeIngestCommand(ingest, profile.ingestEntrypointExample)}\`, so also add whatever build configuration that command needs${ingest.kind === "manual" && ingest.requiresBuildTask ? `, including a "${ingest.requiresBuildTask}" task in "${toolchain.packageManager.dependency.mode === "agent-declares" ? toolchain.packageManager.dependency.file : "the build file"}" that runs the script` : ""}.`;
   return [
     ...input.confirmed && input.confirmed.length ? [
-      `Create an ingestion script under "${input.ingestDir}/" at the repo root.`,
+      `Write the ingestion script in ${profile.displayName}, at "${ingestScriptDir(profile)}/" in the repo.`,
       `Ingest only these confirmed entities (name, source paths, attributes): ${JSON.stringify(input.confirmed)}.`,
-      `Ingesting writes to Algolia, so the script needs a write API key and App ID \u2014 read them from the ${API_KEY_VAR} and ${APP_ID_VAR} environment variables rather than hardcoding them. The wizard sets these when it runs the script.`,
-      "Use the appropriate Algolia package in the ingestion script. Do not use the raw HTTP API.",
+      `Ingesting writes to Algolia, so the script needs a write API key and App ID \u2014 read them from the ${API_KEY_VAR} and ${APP_ID_VAR} environment variables rather than hardcoding them. ${profile.envReadInstruction} The wizard sets these when it runs the script.`,
+      `Use the official Algolia ${profile.displayName} client (${profile.sdk.packageName}). Do not use the raw HTTP API, and do not use a client for another language.`,
       "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.',
+      getNamedDoc("save-records", profile.sdk.docKey),
+      dependencyInstruction(toolchain),
       "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.`,
+      runInstruction,
       ...sourceSpecificInstructions(input)
     ] : []
   ];
 }
 function searchInstructions(input) {
-  const doc = getFrameworkSpecificDoc(frameworksForDoc(input.uiFramework));
+  const doc = getNamedDoc(
+    "instantsearch-setup",
+    searchDocKey(input.searchStrategy)
+  );
+  const isTemplate = input.searchStrategy === "cdn-template";
+  const placement = isTemplate ? input.searchLocation ? `Add the search UI to the server-rendered template at "${input.searchLocation}" \u2014 ideally a shared layout, so it is reachable across the app.` : `This project has no shared template to host the UI, so create a standalone page at "${input.ingestDir}/search-demo.html" the developer can open directly, and add a TODO explaining how to move the snippet into their own layout.` : `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.`;
   return [
     "Implement an in-app Algolia search experience.",
-    `Build the search UI for ${input.uiFramework}.`,
-    "Follow the Algolia JS SDK reference below for client setup and InstantSearch wiring; prefer it over prior knowledge:",
+    `Build the search UI for ${describeSearchTarget(input.searchStrategy, input.frameworkName)}.`,
+    "Follow the Algolia reference below for client setup and InstantSearch wiring; prefer it over prior knowledge:",
     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 "${input.targetIndex}" index.`,
-    "Read the App ID and a search-only API key from public env vars; never hardcode them. A search-only key is safe to expose client-side.",
+    placement,
+    `It needs at least a working SearchBox and Hits against the "${input.targetIndex}" index.`,
+    isTemplate ? "Load InstantSearch from a CDN with script tags as shown in the reference. Do not add JavaScript package dependencies, a bundler, or a build step." : '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.',
+    isTemplate ? "Read the App ID and search-only API key from server-side configuration/environment and render them into the page (e.g. as data- attributes the script reads); never hardcode them, and never put a write/admin key in HTML." : "Read the App ID and a search-only API key from public env vars; never hardcode them. A search-only key is safe to expose client-side.",
     // appId always resolves (loadActiveProfile throws otherwise); only the
     // search-only key is best-effort and can fall back to a placeholder.
     `Values: App ID "${input.appId}", search-only key ${input.searchKey ? `"${input.searchKey}"` : "(placeholder for the developer to fill in)"}.`,
@@ -3956,20 +4131,22 @@ function searchInstructions(input) {
     // resolved app id / search-only key into ".env" under these exact names
     // right after this step, so a renamed prefix here 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(", ")}.`,
-    '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.',
+    `Use exactly these env var names: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
     "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."
   ];
 }
 function verificationInstructions(input) {
+  const protectedDirs = [
+    .../* @__PURE__ */ new Set([input.ingestDir, ingestScriptDir(input.ingestionProfile)])
+  ];
   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.",
+    `Call verifyImplementation at least once; it runs the mechanical checks available for this repo's languages (${input.verificationLanguages.join(", ")}) 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.",
     "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 ${protectedDirs.map((dir) => `"${dir}/"`).join(" or ")} unless verifyImplementation 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."
@@ -3978,14 +4155,17 @@ function verificationInstructions(input) {
 var IMPLEMENT_CONFIG = {
   ingestion: {
     title: "Algolia ingestion",
+    label: "Ingestion",
     buildInstructions: ingestionInstructions
   },
   search: {
     title: "Algolia search",
+    label: "Search",
     buildInstructions: searchInstructions
   },
   verification: {
     title: "Algolia verification",
+    label: "Verification",
     buildInstructions: verificationInstructions
   }
 };
@@ -4017,11 +4197,10 @@ function buildAgentInstructions(useCase, input, extraInstructions = []) {
   ];
 }
 function formatSummary(useCase, summary) {
-  const label = useCase === "ingestion" ? "Ingestion" : useCase === "search" ? "Search" : "Verification";
-  return `${label}: ${summary}`;
+  return `${IMPLEMENT_CONFIG[useCase].label}: ${summary}`;
 }
-function buildIngestCommand(worktree, runtime, entrypoint) {
-  return `cd ${shellQuote(worktree)} && ${runtime} ${shellQuote(entrypoint)}`;
+function buildIngestCommand(worktree, toolchain, entrypoint) {
+  return `cd ${shellQuote(worktree)} && ${describeIngestCommand(toolchain.ingest, entrypoint)}`;
 }
 function parseIngestRecordCount(output) {
   const match = output.match(/ALGOLIA_WIZARD_RECORD_COUNT=(\d+)/);
@@ -4127,7 +4306,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       const copied = await copyUploadIntoWorktree(
         repoRoot,
         worktree,
-        INGEST_DIR2,
+        INGEST_DIR,
         uploadSourcePath ?? ""
       );
       if (copied.ok) {
@@ -4141,6 +4320,33 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
         );
       }
     }
+    const ingestionProfile = await resolveIngestionProfile(
+      ctx,
+      language,
+      worktree
+    );
+    const toolchain = await resolveToolchain(worktree, ingestionProfile);
+    const verificationLanguages = [
+      .../* @__PURE__ */ new Set([
+        ingestionProfile.id,
+        ...(await detectProfilesFromManifests(worktree)).map((p) => p.id)
+      ])
+    ];
+    const frameworkName = language.frameworks[0]?.name;
+    const searchStrategy = resolveSearchStrategy(
+      frameworkName,
+      verificationLanguages.includes(JAVASCRIPT)
+    );
+    logger.info(
+      {
+        language: ingestionProfile.id,
+        packageManager: toolchain.packageManager.id,
+        ingest: toolchain.ingest.kind,
+        framework: frameworkName,
+        searchStrategy
+      },
+      "implement: resolved ingestion toolchain and search strategy"
+    );
     const input = {
       findings: normalized,
       confirmed: confirmed3,
@@ -4149,23 +4355,31 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       language,
       appId,
       searchKey,
-      searchEnvVars: searchEnvVars(language, appId, searchKey),
-      ingestDir: INGEST_DIR2,
+      searchEnvVars: buildSearchEnvVars(
+        language,
+        searchStrategy,
+        appId,
+        searchKey
+      ),
+      ingestDir: INGEST_DIR,
       ingestionSource,
       uploadFilePath,
-      // language.frameworks already prefers the confirm-framework step output,
-      // so the user's confirmed stack (not just raw detection) picks the flavor.
-      uiFramework: detectUiFramework(language)
+      searchStrategy,
+      frameworkName,
+      ingestionProfile,
+      toolchain,
+      verificationLanguages
     };
+    const searchToolchain = !bundlesJavaScript(searchStrategy) ? void 0 : ingestionProfile.id === JAVASCRIPT ? toolchain : await resolveToolchain(worktree, LANGUAGE_PROFILES[JAVASCRIPT]);
+    const toolchainForUseCase = (useCase) => useCase === "search" ? searchToolchain : toolchain;
     const summaries = [];
     if (uploadWarning) summaries.push(uploadWarning);
     let agentRuns = 0;
-    let ingestRuntime;
     let ingestEntrypoint;
     let ingestScriptRan = false;
     let ingestRecordCount;
     let ingestDurationMs;
-    let installFailed = false;
+    const failedInstalls = /* @__PURE__ */ new Set();
     let ingestOutcomeMessage;
     async function runImplementationUseCase(currentUseCase, extraInstructions = []) {
       if (agentRuns > 0) ctx.recordStepExecution();
@@ -4179,16 +4393,19 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
         tools: toolsForUseCase(currentUseCase, input.ingestionSource),
         outputSchema: implementationOutputSchema
       });
+      const useCaseToolchain = toolchainForUseCase(currentUseCase);
+      if (!useCaseToolchain) return result;
       ctx.notify({
         messages: [`Installing dependencies for ${currentUseCase}\u2026`]
       });
       const installLogId = ctx.logStart("installWorktreeDeps", {
-        useCase: currentUseCase
+        useCase: currentUseCase,
+        language: useCaseToolchain.profile.id
       });
-      const install = await installWorktreeDeps(worktree);
+      const install = await installWorktreeDeps(worktree, useCaseToolchain);
       ctx.logEnd(installLogId, install.ok ? "success" : "error");
       if (!install.ok) {
-        installFailed = true;
+        failedInstalls.add(useCaseToolchain.profile.displayName);
         logger.warn(
           { useCase: currentUseCase, output: install.output },
           "implement: dependency install in worktree failed; generated commands may not run until deps are installed"
@@ -4202,15 +4419,16 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       return runAgent({
         instructions: buildAgentInstructions("verification", input),
         tools: toolsForUseCase("verification"),
-        outputSchema: verificationOutputSchema
+        outputSchema: verificationOutputSchema,
+        // So verifyImplementation runs this repo's checks, not just npm scripts.
+        languages: input.verificationLanguages
       });
     }
     if (useCases.includes("ingestion")) {
-      const { summary, runtime, entrypoint } = await runImplementationUseCase("ingestion");
+      const { summary, entrypoint } = await runImplementationUseCase("ingestion");
       summaries.push(formatSummary("ingestion", summary));
-      ingestRuntime = runtime;
       ingestEntrypoint = entrypoint;
-      if (ingestRuntime && ingestEntrypoint && !installFailed) {
+      if (ingestEntrypoint && toolchain.ingest.kind === "auto" && failedInstalls.size === 0) {
         ctx.clearNotices();
         const runNow = await ctx.requestUserInput({
           prompt: `Run the ingestion script now? This writes records to the "${targetIndex}" index.`,
@@ -4222,13 +4440,13 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
           const profile = await loadActiveProfile();
           ctx.notify({ messages: [`Writing records to "${targetIndex}"\u2026`] });
           const scriptLogId = ctx.logStart("runIngestScript", {
-            runtime: ingestRuntime,
+            language: ingestionProfile.id,
             entrypoint: ingestEntrypoint
           });
           const startedAt = Date.now();
           const run2 = await runIngestScript(
             worktree,
-            ingestRuntime,
+            toolchain,
             ingestEntrypoint,
             {
               [APP_ID_VAR]: profile.appId,
@@ -4255,7 +4473,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
             outcomeMessage = `\u26A0\uFE0F The ingestion script did not run: ${run2.reason}`;
             logger.warn(
               {
-                runtime: ingestRuntime,
+                language: ingestionProfile.id,
                 entrypoint: ingestEntrypoint,
                 reason: run2.reason
               },
@@ -4278,7 +4496,7 @@ ${run2.output}` : status;
             outcomeMessage = `\u274C Ingestion failed.${run2.output ? ` ${run2.output}` : ""}`;
             logger.warn(
               {
-                runtime: ingestRuntime,
+                language: ingestionProfile.id,
                 entrypoint: ingestEntrypoint,
                 output: run2.output
               },
@@ -4295,10 +4513,28 @@ ${run2.output}` : status;
         }
       }
       const commandMessages = [`Open the worktree: cd ${shellQuote(worktree)}`];
-      if (ingestRuntime && ingestEntrypoint) {
+      if (ingestEntrypoint) {
         commandMessages.push(
-          `Ingestion command: ${buildIngestCommand(worktree, ingestRuntime, ingestEntrypoint)}`
+          `Ingestion command: ${buildIngestCommand(worktree, toolchain, ingestEntrypoint)}`
         );
+        if (toolchain.ingest.kind === "manual") {
+          commandMessages.push(
+            `The wizard does not run ${ingestionProfile.displayName} ${toolchain.packageManager.id} projects \u2014 run the command above yourself to ingest.`
+          );
+          const missingTask = await missingBuildTask(worktree, toolchain);
+          if (missingTask) {
+            const warning = `\u26A0\uFE0F The command above needs a "${missingTask}" task, which is not in ${toolchain.packageManager.dependency.mode === "agent-declares" ? toolchain.packageManager.dependency.file : "the build file"} \u2014 add it before running, or run the script through your IDE instead.`;
+            commandMessages.push(warning);
+            summaries.push(warning);
+          }
+        }
+      }
+      if (ingestionSource === "local") {
+        const limitation = localSourceLimitation(worktree, ingestionProfile);
+        if (limitation) {
+          commandMessages.push(`\u26A0\uFE0F ${limitation}`);
+          summaries.push(`\u26A0\uFE0F ${limitation}`);
+        }
       }
       await ctx.requestUserInput({
         // No question being asked here, just an acknowledgement — the
@@ -4309,7 +4545,20 @@ ${run2.output}` : status;
         messages: ingestOutcomeMessage ? [ingestOutcomeMessage, ...commandMessages] : commandMessages
       });
     }
-    if (useCases.includes("search")) {
+    const skipSearch = useCases.includes("search") && !canScaffoldSearchUI(input.searchStrategy);
+    if (skipSearch) {
+      const target = describeSearchTarget(
+        input.searchStrategy,
+        input.frameworkName
+      );
+      summaries.push(
+        `Search UI skipped: the wizard can't scaffold a native search UI for ${target}. Your records are in the "${targetIndex}" index \u2014 build the UI with Algolia's mobile InstantSearch libraries (https://www.algolia.com/doc/guides/building-search-ui/what-is-instantsearch/ios/ for iOS, .../android for Android).`
+      );
+      track("AI Wizard Search UI Skipped", {
+        framework: input.frameworkName ?? "unknown"
+      });
+    }
+    if (useCases.includes("search") && !skipSearch) {
       let extraInstructions = [];
       const preSearchFiles = new Set(await listChangedFiles(worktree));
       for (let attempt = 1; attempt <= MAX_IMPLEMENT_VERIFICATION_ATTEMPTS; attempt++) {
@@ -4380,9 +4629,9 @@ ${run2.output}` : status;
         "implement: agent reported success but no files changed in the worktree"
       );
     }
-    if (installFailed) {
+    if (failedInstalls.size > 0) {
       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".'
+        `\u26A0\uFE0F Dependency install in the worktree failed. Install the ${[...failedInstalls].join(" and ")} dependencies in the worktree before the command below, or it will fail on a missing package.`
       );
     }
     return {
@@ -4390,10 +4639,10 @@ ${run2.output}` : status;
       filesChanged,
       summary: summaries.join("\n\n"),
       worktreePath: worktree,
-      ...useCases.includes("ingestion") && ingestRuntime && ingestEntrypoint ? {
+      ...useCases.includes("ingestion") && ingestEntrypoint ? {
         ingestCommand: buildIngestCommand(
           worktree,
-          ingestRuntime,
+          toolchain,
           ingestEntrypoint
         ),
         ingestScriptRan,
@@ -4722,20 +4971,20 @@ function parseCliArgs(argv) {
 }
 
 // src/lib/resetState.ts
-import { readdir as readdir4, rm as rm2 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { readdir as readdir5, rm as rm2 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 var KEEP = ["wizard.log"];
 async function resetProjectState() {
   const dir = stateDir();
   let entries;
   try {
-    entries = await readdir4(dir);
+    entries = await readdir5(dir);
   } catch {
     return { dir, removed: [] };
   }
   const targets = entries.filter((name) => !KEEP.includes(name));
   await Promise.all(
-    targets.map((name) => rm2(join13(dir, name), { recursive: true, force: true }))
+    targets.map((name) => rm2(join14(dir, name), { recursive: true, force: true }))
   );
   return { dir, removed: targets };
 }

package/docs/algolia-sdk/README.md

@@ -1,36 +1,49 @@
-# Algolia JS SDK reference (search)
+# Algolia SDK reference
 
-Authoritative reference for wiring **Algolia search** in JavaScript/TypeScript apps.
-Prefer the method shapes documented here over prior knowledge — they are pinned to
-the current stable majors and avoid known pitfalls (e.g. v5 type mismatches with
-InstantSearch).
+Authoritative reference for the code the wizard generates. Prefer the method shapes
+documented here over prior knowledge — they are pinned to the current stable majors
+and avoid known pitfalls (e.g. v5 type mismatches with InstantSearch).
 
-## Versions
+Docs are loaded by exact name (`<name>-<key>.md`), keyed off the language registry in
+`src/lib/languages.ts` and the framework registry in `src/lib/frameworks.ts`. Adding a
+language means adding its `save-records-<key>.md`, or the doc-coverage test fails.
 
-- `algoliasearch` v5 (install `^5`)
-- `react-instantsearch` v7 (install `^7`)
-- `vue-instantsearch` v4 (install `^4`)
-- `instantsearch.js` v4 (install `^4`) — also the recommended choice for Angular
-- `angular-instantsearch` — DEPRECATED/archived (Sep 2024); do not use, prefer `instantsearch.js`
+## Ingestion clients
 
-Always install the **latest stable** within the major (use a caret range like `^5` /
-`^7`); never pin an exact patch.
+One `save-records-<key>.md` per language Algolia ships an official API client for.
+Install the latest stable within the major; never pin an exact patch.
+
+| Language | Package | Version |
+| --- | --- | --- |
+| JavaScript/TypeScript | `algoliasearch` | `^5` |
+
+## Search UI
+
+| Strategy | Doc | Packages |
+| --- | --- | --- |
+| React (incl. Next.js) | `instantsearch-setup-react.md` | `react-instantsearch` v7 |
+| Vue (incl. Nuxt) | `instantsearch-setup-vue.md` | `vue-instantsearch` v4 |
+| Angular | `instantsearch-setup-angular.md` | `instantsearch.js` v4 |
+| Plain JavaScript | `instantsearch-setup-js.md` | `instantsearch.js` v4 |
+| Server-rendered templates | `instantsearch-setup-templates.md` | CDN script tags, no bundler |
+
+`angular-instantsearch` is DEPRECATED/archived (Sep 2024); use `instantsearch.js`.
+
+Server-rendered templates cover Algolia's official framework integrations — Rails,
+Django, Laravel, Symfony — and any backend with no JavaScript build.
 
 ## Golden rules
 
+- Ingestion is a **write** op: it needs a write key and must stay server-side. Read the
+  credentials from the `ALGOLIA_APPLICATION_ID` and `ALGOLIA_WRITE_API_KEY` env vars.
 - Use a **search-only API key** in any browser/client code. It is safe to expose.
-  NEVER ship an admin or any write-capable key to the client.
-- Read the Application ID and search-only key from **public env vars**, never hardcode
-  them inline.
+  NEVER ship an admin or any write-capable key to the client, and never render one into
+  HTML.
+- Read the Application ID and search-only key from env vars or server-side config, never
+  hardcode them inline.
 - Instantiate the search client **once, outside your components**, and pass a stable
-  reference. Do not inline `algoliasearch(...)` as a prop value — it breaks the
-  client cache and causes re-renders.
+  reference. Do not inline `algoliasearch(...)` as a prop value — it breaks the client
+  cache and causes re-renders.
 - For InstantSearch, import the client from `algoliasearch/lite` (smaller bundle and
-  correct types — see `instantsearch-setup.md`).
-
-## Files
-
-- `instantsearch-setup.md` — framework-specific InstantSearch wiring (React, Vue,
-  Angular, vanilla). Use this for the in-app search UI.
-- `search-single-index.md` — direct/manual search via the core client
-  (`searchSingleIndex`), for cases where InstantSearch is not used.
+  correct types).
+- Every record needs an `objectID`. `saveObjects` auto-batches in groups of 1,000.

package/docs/algolia-sdk/instantsearch-setup-templates.md

@@ -0,0 +1,92 @@
+# InstantSearch setup (CDN, server-rendered templates)
+
+Use this when HTML is rendered server-side and there is no bundler or npm build
+step: Rails ERB, Django templates, Laravel Blade, Symfony Twig.
+
+## CDN tags (shared layout)
+
+```html
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/instantsearch.css@8/themes/satellite-min.css">
+<script src="https://cdn.jsdelivr.net/npm/algoliasearch@5/dist/lite/builds/browser.umd.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/instantsearch.js@4/dist/instantsearch.production.min.js"></script>
+```
+
+Globals these expose:
+
+- `window['algoliasearch/lite']` → `{ liteClient }`. The lite UMD build's global is
+  the literal string key `algoliasearch/lite`, **not** `algoliasearch.liteClient`.
+  (`dist/algoliasearch.umd.js` is the full write-capable client under
+  `window.algoliasearch` — don't use it for search UI.)
+- `window.instantsearch` → the callable factory, with `.widgets`, `.connectors`.
+
+Floating `@5`/`@4`/`@8` track the newest patch. Adding SRI `integrity` requires
+exact pins instead (Algolia's install page publishes hashes for
+`algoliasearch@5.56.0`, `instantsearch.js@4.108.0`, `instantsearch.css@8.18.0`).
+
+## Containers
+
+```html
+<div id="search"
+     data-algolia-app-id="APP_ID"
+     data-algolia-search-key="SEARCH_ONLY_KEY"
+     data-algolia-index="products">
+  <div id="searchbox"></div>
+  <div id="hits"></div>
+</div>
+```
+
+## Init
+
+Inline `<script>` must run after both CDN scripts — put it at the end of `<body>`,
+not in `<head>`.
+
+```html
+<script>
+  const el = document.getElementById('search')
+  const { liteClient: algoliasearch } = window['algoliasearch/lite']
+  const searchClient = algoliasearch(
+    el.dataset.algoliaAppId,
+    el.dataset.algoliaSearchKey
+  )
+
+  const search = instantsearch({ indexName: el.dataset.algoliaIndex, searchClient })
+
+  search.addWidgets([
+    instantsearch.widgets.searchBox({ container: '#searchbox' }),
+    instantsearch.widgets.hits({
+      container: '#hits',
+      templates: {
+        item(hit, { html, components }) {
+          return html`
+            <article>
+              <h3>${components.Highlight({ attribute: 'name', hit })}</h3>
+              <p>${hit.description}</p>
+            </article>
+          `
+        },
+      },
+    }),
+  ])
+
+  search.start()
+</script>
+```
+
+`html` arrives as a property of the template function's second argument — it is
+not an import and not a global. It escapes interpolated values, so it is the XSS
+guard: never string-concatenate hit values or assign them to `innerHTML`.
+
+## Injecting credentials from server config
+
+Render App ID and the search-only key into `data-` attributes (every engine below
+escapes attribute output), then read them from `dataset` — attribute dashes become
+camelCase: `data-algolia-app-id` → `el.dataset.algoliaAppId`. Never interpolate a
+credential into a JS string literal.
+
+- ERB: `data-algolia-app-id="<%= Rails.application.credentials.algolia[:app_id] %>"`
+- Django: `data-algolia-app-id="{{ algolia_app_id }}"` (from the view context)
+- Blade: `data-algolia-app-id="{{ config('services.algolia.app_id') }}"`
+- Twig: `data-algolia-app-id="{{ algolia_app_id }}"` (from a Twig global/parameter)
+
+Only ever a **search-only** API key client-side. A write or admin key must never
+appear in HTML, a `data-` attribute, or inline JS.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.9.0-rc.72.60",
+  "version": "0.9.0-rc.74.64",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {
@@ -22,7 +22,7 @@
     "prepare": "husky",
     "prepublishOnly": "pnpm build",
     "reset": "tsx ./scripts/reset-state.ts",
-    "test:fixtures": "touch .env && tsx --env-file=.env ./fixtures/run-fixtures.ts",
+    "test:toolchains": "tsx ./scripts/verify-toolchains.ts",
     "test:tools": "tsx ./tool-evals/toolEval.ts",
     "test": "vitest",
     "typecheck": "tsc --noEmit -p tsconfig.json"

package/docs/algolia-sdk/search-single-index.md

@@ -1,42 +0,0 @@
-# Direct search with the core client (v5)
-
-Use this only when NOT using InstantSearch (e.g. a custom search box, a server
-route, or programmatic queries). For UI, prefer `instantsearch-setup-<framework>.md`.
-
-## Client
-
-```ts
-import { algoliasearch } from 'algoliasearch'
-
-const client = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
-```
-
-In v5 there is no `client.initIndex(...)`. Index methods take the index name as a
-parameter on the client. Every method takes a single options object.
-
-## Search a single index
-
-```ts
-const { hits, nbHits } = await client.searchSingleIndex({
-  indexName: 'INDEX_NAME',
-  searchParams: { query: 'shoes', hitsPerPage: 20, page: 0 },
-})
-```
-
-## Search multiple indices / queries in one request
-
-```ts
-const { results } = await client.search({
-  requests: [
-    { indexName: 'INDEX_NAME', query: 'shoes' },
-    { indexName: 'OTHER_INDEX', query: 'shoes' },
-  ],
-})
-```
-
-## Notes
-
-- `searchSingleIndex` returns up to 1,000 hits. For larger exports use the `browse`
-  operation instead.
-- Keep using a **search-only** key for any client-exposed search. Use an admin key
-  only in trusted server-side code.