@algolia/wizard 0.6.0-rc.51.25 → 0.6.0-rc.51.26

package/dist/main.js

@@ -2200,6 +2200,7 @@ function shellQuote(value) {
 // src/lib/languages.ts
 var ENTRYPOINT_TOKEN = "{entrypoint}";
 var INGEST_DIR = ".algolia-wizard";
+var VISIBLE_INGEST_DIR = "algolia-wizard";
 var PY_VENV = `${INGEST_DIR}/.venv`;
 var PY_VENV_PYTHON = `${PY_VENV}/bin/python`;
 var PY_REQUIREMENTS = `${INGEST_DIR}/requirements.txt`;
@@ -2308,7 +2309,8 @@ var LANGUAGE_PROFILES = {
         // -x skips the venv this same directory holds; without it the check
         // compiles every installed package instead of the generated script.
         label: "python compileall",
-        argv: ["python3", "-m", "compileall", "-q", "-x", "[.]venv", INGEST_DIR]
+        argv: ["python3", "-m", "compileall", "-q", "-x", "[.]venv", INGEST_DIR],
+        requiresFile: INGEST_DIR
       }
     ],
     envReadInstruction: "Read them from `os.environ`.",
@@ -2397,7 +2399,8 @@ var LANGUAGE_PROFILES = {
       {
         id: "gomod",
         // Imports in the generated file are the declaration; `go mod tidy`
-        // resolves and fetches them.
+        // resolves and fetches them — which only works because the script lives
+        // outside INGEST_DIR (see VISIBLE_INGEST_DIR).
         dependency: { mode: "code-imports" },
         installSteps: [{ argv: ["go", "mod", "tidy"] }],
         ingest: {
@@ -2412,7 +2415,7 @@ var LANGUAGE_PROFILES = {
       versionPin: "v4",
       docKey: "go"
     },
-    ingestEntrypointExample: `${INGEST_DIR}/ingest.go`,
+    ingestEntrypointExample: `${VISIBLE_INGEST_DIR}/ingest.go`,
     verification: [
       { label: "go vet", argv: ["go", "vet", "./..."], requiresFile: "go.mod" }
     ],
@@ -2448,7 +2451,11 @@ var LANGUAGE_PROFILES = {
       {
         id: "gradle",
         detectFiles: ["build.gradle", "build.gradle.kts"],
-        dependency: { mode: "agent-declares", file: "build.gradle" },
+        dependency: {
+          mode: "agent-declares",
+          file: "build.gradle",
+          alternatives: ["build.gradle.kts"]
+        },
         installSteps: [],
         // Auto-running means executing the repo's own ./gradlew wrapper; out of
         // scope for now, so the wizard writes the code and prints the command.
@@ -2487,13 +2494,33 @@ var LANGUAGE_PROFILES = {
     packageManagers: [
       {
         id: "gradle",
-        dependency: { mode: "agent-declares", file: "build.gradle.kts" },
+        detectFiles: ["build.gradle.kts", "build.gradle"],
+        dependency: {
+          mode: "agent-declares",
+          file: "build.gradle.kts",
+          alternatives: ["build.gradle"]
+        },
         installSteps: [],
         ingest: {
           kind: "manual",
           entrypointExtensions: [".kt"],
           runCommand: "./gradlew runAlgoliaIngest"
         }
+      },
+      // Kotlin/Maven is rare but real, and pom.xml is a Kotlin manifest — without
+      // this spec such a repo falls through to Gradle and is told to run a
+      // ./gradlew task that doesn't exist. Compiling needs the repo's own
+      // kotlin-maven-plugin, so the run stays the developer's step.
+      {
+        id: "maven",
+        detectFiles: ["pom.xml"],
+        dependency: { mode: "agent-declares", file: "pom.xml" },
+        installSteps: [{ argv: ["mvn", "-q", "-DskipTests", "compile"] }],
+        ingest: {
+          kind: "manual",
+          entrypointExtensions: [".kt"],
+          runCommand: "mvn -q org.codehaus.mojo:exec-maven-plugin:3.5.0:java -Dexec.mainClass=AlgoliaWizardIngest"
+        }
       }
     ],
     sdk: {
@@ -2660,9 +2687,12 @@ var LANGUAGE_PROFILES = {
     ingestEntrypointExample: `${INGEST_DIR}/ingest.dart`,
     verification: [
       {
+        // Gated on the directory it analyzes, not just pubspec.yaml: a run that
+        // only built a search UI never created it, and `dart analyze` on a
+        // missing path fails the whole verification pass.
         label: "dart analyze",
         argv: ["dart", "analyze", INGEST_DIR],
-        requiresFile: "pubspec.yaml"
+        requiresFile: INGEST_DIR
       }
     ],
     envReadInstruction: "Read them from `Platform.environment`.",
@@ -2670,6 +2700,13 @@ var LANGUAGE_PROFILES = {
   }
 };
 var DEFAULT_LANGUAGE_ID = "javascript";
+var JAVASCRIPT = "javascript";
+var CURATED_LANGUAGES = Object.values(
+  LANGUAGE_PROFILES
+).map((profile2) => profile2.displayName);
+function isBackendLanguage(profile2) {
+  return profile2.id !== JAVASCRIPT;
+}
 function normalizeLanguageName(name) {
   return name.toLowerCase().trim().replace(/[\s_-]+/g, "");
 }
@@ -2683,6 +2720,14 @@ 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,
@@ -2704,6 +2749,17 @@ function isWorktreeRelativeCommand(command) {
 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) {
@@ -2730,13 +2786,27 @@ async function detectProfilesFromManifests(root) {
 async function hasProfileManifest(root, profile2) {
   return profileManifestPresent(root, profile2, {});
 }
+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, profile2) {
   const matched = profile2.packageManagers.find(
     (pm) => [...pm.lockfiles ?? [], ...pm.detectFiles ?? []].some(
       (f) => existsSync2(join9(root, f))
     )
   );
-  const packageManager = matched ?? profile2.packageManagers[0];
+  const packageManager = resolveDeclaredManifest(
+    root,
+    matched ?? profile2.packageManagers[0]
+  );
   let { installSteps, ingest } = packageManager;
   installSteps = installSteps.map(
     (step) => isWorktreeRelativeCommand(step.argv[0]) ? { ...step, argv: withCommand(step.argv, join9(root, step.argv[0])) } : step
@@ -2860,27 +2930,61 @@ import { join as join11 } from "node:path";
 
 // src/lib/tools/utils/runCommand.ts
 import { spawn as spawn2 } from "node:child_process";
-function runCommand(command, args, cwd) {
+var INSTALL_TIMEOUT_MS = 15 * 6e4;
+var INGEST_TIMEOUT_MS = 15 * 6e4;
+var VERIFY_TIMEOUT_MS = 10 * 6e4;
+var KILL_GRACE_MS = 5e3;
+function runCommand(command, args, options = {}) {
+  const { cwd, env, timeoutMs = VERIFY_TIMEOUT_MS } = options;
   return new Promise((resolve4) => {
     let output = "";
+    let settled = false;
     const child = spawn2(command, args, {
       cwd,
-      stdio: ["ignore", "pipe", "pipe"]
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      ...env ? { env: { ...process.env, ...env } } : {}
     });
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve4(result);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS).unref();
+      const seconds = Math.round(timeoutMs / 1e3);
+      settle({
+        code: 1,
+        output: `${output}
+Timed out after ${seconds}s: ${command} ${args.join(" ")}`.trim(),
+        timedOut: true
+      });
+    }, timeoutMs);
     child.stdout?.on("data", (d) => output += d);
     child.stderr?.on("data", (d) => output += d);
     child.on(
       "error",
-      (err) => resolve4({ code: 1, output: `Failed to run ${command}: ${err.message}` })
+      (err) => settle({
+        code: 1,
+        output: `Failed to run ${command}: ${err.message}`,
+        timedOut: false
+      })
+    );
+    child.on(
+      "close",
+      (code) => settle({ code: code ?? 1, output, timedOut: false })
     );
-    child.on("close", (code) => resolve4({ code: code ?? 1, output }));
   });
 }
 
 // src/lib/tools/repoVerification.ts
 var VERIFICATION_SCRIPT_CANDIDATES = ["lint", "typecheck", "check"];
 async function runCheck(command, binary, args) {
-  const { code, output } = await runCommand(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() {
@@ -2914,7 +3018,7 @@ async function runRepoVerificationCheck(languages = [DEFAULT_LANGUAGE_ID]) {
   const checks = [];
   const limitations = [];
   for (const id of ids) {
-    if (id === DEFAULT_LANGUAGE_ID) {
+    if (id === JAVASCRIPT) {
       const result = await javascriptChecks();
       if ("checks" in result) checks.push(...result.checks);
       else limitations.push(result.limitation);
@@ -3085,7 +3189,11 @@ var DEFAULT_TOOL_LIMITS = {
   read: 20,
   match: 100
 };
-function createToolContext(limits = DEFAULT_TOOL_LIMITS, cwd = process.cwd(), languages = [DEFAULT_LANGUAGE_ID]) {
+function createToolContext({
+  limits = DEFAULT_TOOL_LIMITS,
+  cwd = process.cwd(),
+  languages = [DEFAULT_LANGUAGE_ID]
+} = {}) {
   return {
     root: cwd,
     cwd,
@@ -3164,11 +3272,7 @@ async function runAgent(req) {
     baseURL: PROXY_BASE_URL,
     fetch: proxyFetch
   });
-  const toolContext = createToolContext(
-    void 0,
-    void 0,
-    req.languages
-  );
+  const toolContext = createToolContext({ languages: req.languages });
   const readTools = ["readFile", "searchFiles", "listFiles"];
   const hasReadTools = !req.tools || req.tools.some((t) => readTools.includes(t));
   const instructions = [
@@ -3363,7 +3467,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.6.0-rc.51.25",
+  version: "0.6.0-rc.51.26",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3473,17 +3577,6 @@ var confirmLanguageSchema = z19.object({
   languages: detectLanguageSchema.shape.languages
 });
 var OTHER_OPTION = "Other";
-var CURATED_LANGUAGES = Object.values(LANGUAGE_PROFILES).map(
-  (profile2) => profile2.displayName
-);
-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 fold = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
-  return fold(a) !== "" && fold(a) === fold(b);
-}
 function confirmed(languages) {
   track("AI Wizard Language Confirmed", { languages });
   return { languages };
@@ -3612,6 +3705,27 @@ function resolveSearchStrategy(frameworkName, hasJavaScriptInStack) {
 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":
@@ -3819,7 +3933,7 @@ ${JSON.stringify(s.output, null, 2)}`
 }
 function formatReviewSummary(result) {
   const nextStepLines = result.nextSteps.map((step) => {
-    const isIngestCommand = step.includes(".algolia-wizard/") || step.includes("AlgoliaWizardIngest");
+    const isIngestCommand = step.includes("algolia-wizard/") || step.includes("AlgoliaWizardIngest");
     const isWorktreeCommand = step.includes("/worktrees/");
     return {
       text: `\u2192 ${step}`,
@@ -3861,7 +3975,7 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 import z24 from "zod";
 
 // src/lib/worktree.ts
-import { execFile, spawn as spawn3 } from "node:child_process";
+import { execFile } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
 import { copyFile, mkdir as mkdir6, readdir as readdir4, readFile as readFile8, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
 import {
@@ -3934,28 +4048,12 @@ async function createWorktree(repoRoot) {
   await git(["-C", repoRoot, "worktree", "add", "-b", branch, path, "HEAD"]);
   return { path, branch };
 }
-function spawnStep(worktreePath, argv) {
-  return new Promise((resolve4) => {
-    let output = "";
-    const child = spawn3(argv[0], [...argv.slice(1)], {
-      cwd: worktreePath,
-      shell: false,
-      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 ${argv.join(" ")}: ${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: profile2, installSteps, packageManager } = toolchain;
@@ -4050,29 +4148,12 @@ async function runIngestScript(worktreePath, toolchain, entrypoint, env = {}) {
     };
   }
   const argv = resolveIngestArgv(ingest, entrypoint);
-  return new Promise((resolveRun) => {
-    let output = "";
-    const child = spawn3(argv[0], argv.slice(1), {
-      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 ${argv.join(" ")}: ${err.message}`
-      })
-    );
-    child.on(
-      "close",
-      (code) => resolveRun({ ran: true, ok: code === 0, output: output.trim() })
-    );
+  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();
@@ -4299,28 +4380,11 @@ var verificationOutputSchema = z24.object({
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
-var INGEST_DIR2 = ".algolia-wizard";
-function publicEnvPrefix(language, strategy) {
-  if (strategy === "cdn-template" || strategy === "none") return "";
-  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, strategy, appId, searchKey) {
-  const prefix = publicEnvPrefix(language, strategy);
   return [
     {
       name: `${prefix}ALGOLIA_APP_ID`,
@@ -4333,17 +4397,12 @@ function searchEnvVars(language, strategy, appId, searchKey) {
   ];
 }
 async function resolveIngestionProfile(ctx, language, repoRoot) {
-  const fallback = LANGUAGE_PROFILES[DEFAULT_LANGUAGE_ID];
-  const confirmed3 = language.languages.map((l) => resolveLanguageProfile(l.name)).filter((p) => p !== void 0);
-  const onDisk = await detectProfilesFromManifests(repoRoot);
-  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()
-  ];
+  const { candidates, confirmed: confirmed3, onDisk } = await pickIngestionCandidates(
+    repoRoot,
+    language.languages.map((l) => l.name)
+  );
   if (candidates.length === 0) {
-    const chosen = confirmed3[0] ?? onDisk[0] ?? fallback;
+    const chosen = confirmed3[0] ?? onDisk[0] ?? LANGUAGE_PROFILES[DEFAULT_LANGUAGE_ID];
     logger.warn(
       {
         confirmed: language.languages.map((l) => l.name),
@@ -4355,9 +4414,10 @@ async function resolveIngestionProfile(ctx, language, repoRoot) {
     return chosen;
   }
   if (candidates.length === 1) return candidates[0];
-  const backends = candidates.filter((p) => p.id !== DEFAULT_LANGUAGE_ID);
+  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?",
@@ -4449,6 +4509,9 @@ function searchInstructions(input) {
   ];
 }
 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 ?? [])}.`,
@@ -4456,7 +4519,7 @@ function verificationInstructions(input) {
     "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."
@@ -4465,14 +4528,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
   }
 };
@@ -4504,8 +4570,7 @@ 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, toolchain, entrypoint) {
   return `cd ${shellQuote(worktree)} && ${describeIngestCommand(toolchain.ingest, entrypoint)}`;
@@ -4614,7 +4679,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) {
@@ -4643,7 +4708,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     const frameworkName = language.frameworks[0]?.name;
     const searchStrategy = resolveSearchStrategy(
       frameworkName,
-      verificationLanguages.includes(DEFAULT_LANGUAGE_ID)
+      verificationLanguages.includes(JAVASCRIPT)
     );
     logger.info(
       {
@@ -4663,8 +4728,13 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       language,
       appId,
       searchKey,
-      searchEnvVars: searchEnvVars(language, searchStrategy, appId, searchKey),
-      ingestDir: INGEST_DIR2,
+      searchEnvVars: buildSearchEnvVars(
+        language,
+        searchStrategy,
+        appId,
+        searchKey
+      ),
+      ingestDir: INGEST_DIR,
       ingestionSource,
       uploadFilePath,
       searchStrategy,
@@ -4673,10 +4743,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       toolchain,
       verificationLanguages
     };
-    const searchToolchain = searchStrategy === "cdn-template" || searchStrategy === "none" ? void 0 : ingestionProfile.id === DEFAULT_LANGUAGE_ID ? toolchain : await resolveToolchain(
-      worktree,
-      LANGUAGE_PROFILES[DEFAULT_LANGUAGE_ID]
-    );
+    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);
@@ -4685,7 +4752,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     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();
@@ -4711,7 +4778,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       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"
@@ -4734,7 +4801,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       const { summary, entrypoint } = await runImplementationUseCase("ingestion");
       summaries.push(formatSummary("ingestion", summary));
       ingestEntrypoint = entrypoint;
-      if (ingestEntrypoint && toolchain.ingest.kind === "auto" && !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.`,
@@ -4838,7 +4905,7 @@ ${run.output}` : status;
         messages: ingestOutcomeMessage ? [ingestOutcomeMessage, ...commandMessages] : commandMessages
       });
     }
-    const skipSearch = useCases.includes("search") && input.searchStrategy === "none";
+    const skipSearch = useCases.includes("search") && !canScaffoldSearchUI(input.searchStrategy);
     if (skipSearch) {
       const target = describeSearchTarget(
         input.searchStrategy,
@@ -4847,7 +4914,6 @@ ${run.output}` : status;
       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).`
       );
-      ctx.setUserInput("implementation", "success");
       track("AI Wizard Search UI Skipped", {
         framework: input.frameworkName ?? "unknown"
       });
@@ -4923,9 +4989,9 @@ ${run.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. Install the ${ingestionProfile.displayName} dependencies in the worktree before the command below, or it will fail on a missing package.`
+        `\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 {

package/docs/algolia-sdk/README.md

@@ -57,8 +57,3 @@ Django, Laravel, Symfony — and any backend with no JavaScript build.
 - For InstantSearch, import the client from `algoliasearch/lite` (smaller bundle and
   correct types).
 - Every record needs an `objectID`. `saveObjects` auto-batches in groups of 1,000.
-
-## Other files
-
-- `search-single-index.md` — direct/manual search via the core client
-  (`searchSingleIndex`), for cases where InstantSearch is not used.

package/package.json

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

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.