@algolia/wizard 0.34.0-rc.125.243 → 0.34.0-rc.125.245

package/dist/main.js

@@ -2645,7 +2645,7 @@ async function ensureApplication() {
 }
 
 // src/workflows/default.ts
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 
 // src/actions/listIndices.ts
 import { z as z5 } from "zod";
@@ -3085,8 +3085,7 @@ function resolveWriteKey(index, appId) {
     `Algolia Wizard write key for ${index} index`
   );
 }
-async function resolveSearchOnlyKey(index, appId, envKey) {
-  if (envKey) return { key: envKey, source: "env" };
+async function resolveSearchOnlyKey(index, appId) {
   return resolveKey(
     "search",
     index,
@@ -3125,6 +3124,12 @@ function isIgnoredByRule(root, relPath) {
 function isTracked(root, relPath) {
   return gitSucceeds(root, ["ls-files", "--error-unmatch", "--", relPath]);
 }
+async function gitIgnoreStatus(root, target) {
+  const { ignoredByRule, tracked } = await inspect(root, target);
+  if (ignoredByRule === void 0) return "unknown";
+  if (tracked) return "tracked";
+  return ignoredByRule ? "covered" : "needsRule";
+}
 async function inspect(root, target) {
   const relPath = relative2(root, target);
   if (!relPath || relPath.startsWith("..")) {
@@ -3170,31 +3175,9 @@ async function ensureGitIgnored(root, target) {
 }
 
 // src/lib/tools/writeAlgoliaCredentials.ts
-var APP_ID_VAR = "ALGOLIA_APPLICATION_ID";
-var API_KEY_VAR = "ALGOLIA_WRITE_API_KEY";
+var APP_ID_VAR = "ALGOLIA_APP_ID";
+var API_KEY_VAR = "ALGOLIA_WRITE_KEY";
 var INDEX_NAME_VAR = "ALGOLIA_INDEX_NAME";
-var PUBLIC_APP_ID_SUFFIX = "ALGOLIA_APP_ID";
-var PUBLIC_SEARCH_KEY_SUFFIX = "ALGOLIA_SEARCH_KEY";
-var PUBLIC_INDEX_NAME_SUFFIX = "ALGOLIA_INDEX_NAME";
-function publicAppIdVar(prefix) {
-  return `${prefix}${PUBLIC_APP_ID_SUFFIX}`;
-}
-function publicSearchKeyVar(prefix) {
-  return `${prefix}${PUBLIC_SEARCH_KEY_SUFFIX}`;
-}
-function publicIndexNameVar(prefix) {
-  return `${prefix}${PUBLIC_INDEX_NAME_SUFFIX}`;
-}
-function publicSearchEnvVars(prefix, index, appId, searchKey) {
-  return [
-    { name: publicAppIdVar(prefix), value: appId ?? "<your-algolia-app-id>" },
-    {
-      name: publicSearchKeyVar(prefix),
-      value: searchKey ?? "<your-algolia-search-only-api-key>"
-    },
-    { name: publicIndexNameVar(prefix), value: index }
-  ];
-}
 function appendEnv(content, entries) {
   const prefix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
   const lines = entries.map(([name, value]) => `${name}=${value}
@@ -4078,7 +4061,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.34.0-rc.125.243",
+  version: "0.34.0-rc.125.245",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -4483,12 +4466,12 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 };
 
 // src/actions/implement.ts
-import z29 from "zod";
-import { relative as relative6 } from "node:path";
+import z28 from "zod";
+import { relative as relative6, join as join12 } from "node:path";
 
 // src/lib/git.ts
 import { execFile as execFile2 } from "node:child_process";
-import { copyFile, mkdir as mkdir6, readFile as readFile8, stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir6, stat as stat3 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute2, join as join10, resolve as resolve3 } from "node:path";
 var MAX_BUFFER = 32 * 1024 * 1024;
 function git(args) {
@@ -4542,44 +4525,6 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
   }
   return { ok: true, relPath };
 }
-var ENV_FILE_PRECEDENCE = [".env", ".env.local"];
-async function readEnvFileIfExists(path) {
-  try {
-    return await readFile8(path, "utf8");
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-    return void 0;
-  }
-}
-async function definingEnvFile(repoRoot, name) {
-  let found;
-  for (const file of ENV_FILE_PRECEDENCE) {
-    const path = join10(repoRoot, file);
-    const content = await readEnvFileIfExists(path);
-    if (content !== void 0 && hasEnv(content, name)) found = { path, content };
-  }
-  return found;
-}
-function usableEnvValue(content, name) {
-  const value = readEnv(content, name);
-  return value && !value.startsWith("<") ? value : void 0;
-}
-async function readEnvVar(repoRoot, name) {
-  const found = await definingEnvFile(repoRoot, name);
-  return found ? usableEnvValue(found.content, name) : void 0;
-}
-async function writeSearchEnvValues(repoRoot, vars, defaultFileName = ".env") {
-  const written = [];
-  for (const { name, value } of vars) {
-    const found = await definingEnvFile(repoRoot, name);
-    if (found && usableEnvValue(found.content, name) !== void 0) continue;
-    const path = found?.path ?? join10(repoRoot, defaultFileName);
-    const existing = found?.content ?? await readEnvFileIfExists(path) ?? "";
-    await writeFile7(path, upsertEnv(existing, name, value), "utf8");
-    written.push({ name, file: path });
-  }
-  return written;
-}
 function normalizeFindingPaths(findings) {
   return {
     ...findings,
@@ -4660,53 +4605,41 @@ function getFrameworkSpecificDoc(frameworks) {
   return loadAlgoliaDoc("js");
 }
 
-// src/actions/resolveEnvVarPrefix.ts
-import z28 from "zod";
-var resolveEnvVarPrefixSchema = z28.object({
-  publicEnvVarPrefix: detectLanguageSchema.shape.publicEnvVarPrefix
-});
-var resolveEnvVarPrefix = (frameworkName) => runAgent({
-  instructions: [
-    `The developer corrected the project's framework to "${frameworkName}".`,
-    `Determine publicEnvVarPrefix for this framework: check the project's own env var usage first (e.g. names already referenced in code, .env/.env.example); if none exists, fall back to this framework's known convention for exposing env vars to client-side code; use "" when the framework has no such convention (e.g. a backend-only framework).`,
-    "A brand-new project has no existing env var usage to find \u2014 one or two targeted checks (e.g. .env/.env.example, or a grep for the framework's public-prefix convention) are enough to confirm that. Do not keep searching once those turn up nothing; fall back to the framework convention immediately.",
-    'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
-    "When done, call reportStatus"
-  ],
-  tools: ["listFiles", "changeDirectory", "readFile", "searchFiles"],
-  outputSchema: resolveEnvVarPrefixSchema,
-  modelSize: "small"
-});
-
 // src/actions/implement.ts
-var implementSchema = z29.object({
-  summary: z29.string(),
-  ingestCommand: z29.string().optional(),
-  ingestScriptRan: z29.boolean().optional(),
-  ingestRecordCount: z29.number().optional(),
-  ingestDurationMs: z29.number().optional(),
-  ingestionSource: z29.enum(["local", "fileUpload", "generated"]),
-  searchEnvVars: z29.array(
-    z29.object({
-      name: z29.string(),
-      value: z29.string()
-    })
-  ).optional()
+var implementSchema = z28.object({
+  summary: z28.string(),
+  ingestCommand: z28.string().optional(),
+  ingestScriptRan: z28.boolean().optional(),
+  ingestRecordCount: z28.number().optional(),
+  ingestDurationMs: z28.number().optional(),
+  ingestionSource: z28.enum(["local", "fileUpload", "generated"]),
+  searchConfig: z28.object({
+    filePath: z28.string().optional(),
+    vars: z28.array(
+      z28.object({
+        name: z28.string(),
+        value: z28.string()
+      })
+    )
+  }).optional()
 });
-var implementationOutputSchema = z29.object({
-  summary: z29.string(),
-  ingestCommand: z29.string().optional()
+var implementationOutputSchema = z28.object({
+  summary: z28.string(),
+  ingestCommand: z28.string().optional(),
+  // Only for the search use case: the path of whatever module the agent
+  // defined the Algolia config constants in, so the wizard can check it
+  // won't end up gitignored (it's public, meant to be committed).
+  searchConfigFile: z28.string().optional()
 });
-var verificationOutputSchema = z29.object({
-  summary: z29.string(),
-  sufficient: z29.boolean(),
-  additionalInstructions: z29.string().optional()
+var verificationOutputSchema = z28.object({
+  summary: z28.string(),
+  sufficient: z28.boolean(),
+  additionalInstructions: z28.string().optional()
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
 var INGEST_DIR = ".algolia-wizard";
 var JS_LANGUAGES = ["javascript", "typescript", "jsx", "tsx", "node"];
-var ENV_LOCAL_AWARE_PREFIXES = ["VITE_", "NEXT_PUBLIC_", "REACT_APP_"];
 function lower(entries) {
   return entries.map((entry) => entry.name.toLowerCase());
 }
@@ -4715,6 +4648,10 @@ function isJsProject(language) {
     (name) => JS_LANGUAGES.some((js) => name.includes(js))
   );
 }
+var SEARCH_CONFIG_APP_ID = "ALGOLIA_APP_ID";
+var SEARCH_CONFIG_SEARCH_KEY = "ALGOLIA_SEARCH_API_KEY";
+var SEARCH_CONFIG_INDEX_NAME = "ALGOLIA_INDEX_NAME";
+var SEARCH_KEY_PLACEHOLDER = "<your-algolia-search-only-api-key>";
 var UI_FRAMEWORKS = [
   { match: ["vue", "nuxt"], target: "Vue", doc: "vue" },
   { match: ["react", "next"], target: "React", doc: "react" },
@@ -4785,6 +4722,7 @@ function ingestionInstructions(input) {
       "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.",
       ...algoliaClientDoc(input),
       "Install the Algolia client with the project's own package manager via runShell, declaring it in whatever manifest the project uses (e.g. package.json, requirements.txt, Gemfile, go.mod, composer.json) so the dependency is not just installed ad hoc.",
+      `If the script loads its env vars from a file (e.g. via dotenv or an equivalent for its language) rather than the process environment directly, decide that up front and call writeCredentials on that file before you finish the script \u2014 do not wait to discover the need for it by having a writeFile call refused.`,
       "When the script is finished, call reviewScript with its path and wait: running it writes records to a live index, so the developer reads it first. Do not run it before that call returns.",
       'Then run the script yourself via runShell, and report the command you ran as "ingestCommand" so the developer can re-run it. Its explanation must say that running it writes records to Algolia.',
       "The summary should be extremely concise.",
@@ -4807,18 +4745,13 @@ function searchInstructions(input) {
     `Import and render that new component from ${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 search input and results list against the target index.`,
     "If a search box already exists, replace its usage with an import and render of your new component; remove the old implementation.",
     "When rendering results with an existing shared component (e.g. a card), import and reuse that component rather than inlining its markup \u2014 inlining silently drops the styles and behavior its own file provides.",
-    `Read the index name from the ${publicIndexNameVar(input.publicEnvVarPrefix)} env var, which the wizard sets to "${input.targetIndex}". Never hardcode an index name or derive one from the project, file, or component name.`,
-    "Read the App ID, the search-only API key, and the index name from env vars; never hardcode them. A search-only key is safe to expose client-side.",
-    // The key is provisioned only after verification passes, and the wizard
-    // reads the project's env files to decide whether a key already exists —
-    // an agent-scaffolded value there, even a blank one, would be treated as
-    // real and silently override whatever the wizard writes.
-    `Add Algolia App ID "${input.appId}"; leave the search-only key as a placeholder in the code only. Do not create or edit any .env* file (.env, .env.local, etc.) yourself, not even to add a blank placeholder line \u2014 the wizard resolves the real key and writes it there itself.`,
-    // The wizard writes these exact names into the project's env files right after this step.
-    `Use exactly these env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
+    `Define ${SEARCH_CONFIG_APP_ID}, ${SEARCH_CONFIG_SEARCH_KEY}, and ${SEARCH_CONFIG_INDEX_NAME} as exported constants in a module that fits this project's existing conventions for shared client-side config \u2014 reuse an existing one if it already holds config like this, or add a small new one otherwise. These are PUBLIC values, safe to commit and expose client-side: never read them from an environment variable or a .env* file, and never hardcode them anywhere except in that one module (import them wherever the search client needs them).`,
+    `Set ${SEARCH_CONFIG_APP_ID} to "${input.appId}" and ${SEARCH_CONFIG_INDEX_NAME} to "${input.targetIndex}".`,
+    input.searchKey ? `Set ${SEARCH_CONFIG_SEARCH_KEY} to "${input.searchKey}".` : `A real search-only key could not be provisioned${input.searchKeyError ? ` (${input.searchKeyError})` : ""} \u2014 set ${SEARCH_CONFIG_SEARCH_KEY} to the placeholder "${SEARCH_KEY_PLACEHOLDER}" and add a prominent TODO for the developer to fill in a real one.`,
+    'Report the repo-relative path of that module as "searchConfigFile" in your final status.',
     "Install any Algolia packages you import with the project's own package manager via runShell, and declare them in the project's dependency manifest.",
     "Match the styles of the application as closely as possible.",
-    "The summary should be extremely concise; do not mention env var setup or manual testing steps \u2014 the wizard writes the resolved credentials to the project env files and reports that separately."
+    "The summary should be extremely concise; do not mention manual testing steps."
   ];
 }
 function verificationInstructions(input) {
@@ -4949,21 +4882,6 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     languages: ctx.getStepOutput("confirm-language")?.languages ?? scan.languages,
     frameworks: ctx.getStepOutput("confirm-framework")?.frameworks ?? scan.frameworks
   };
-  const normalizeFrameworkName = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
-  const confirmedPrimaryFramework = language.frameworks[0]?.name;
-  const frameworkWasCorrected = confirmedPrimaryFramework !== void 0 && !scan.frameworks.some(
-    (fw) => normalizeFrameworkName(fw.name) === normalizeFrameworkName(confirmedPrimaryFramework)
-  );
-  const publicEnvVarPrefixPromise = frameworkWasCorrected ? resolveEnvVarPrefix(confirmedPrimaryFramework).then(
-    (r) => r.publicEnvVarPrefix,
-    (err) => {
-      logger.warn(
-        { err, framework: confirmedPrimaryFramework },
-        "implement: could not re-resolve publicEnvVarPrefix after a framework correction; using the stale scan value"
-      );
-      return scan.publicEnvVarPrefix;
-    }
-  ) : Promise.resolve(scan.publicEnvVarPrefix);
   const selected = ctx.getStepOutput(
     "select-index"
   );
@@ -5044,49 +4962,42 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
       );
     }
   }
-  const publicEnvVarPrefix = await publicEnvVarPrefixPromise;
+  const summaries = [];
+  if (uploadWarning) summaries.push(uploadWarning);
+  let searchKey;
+  let searchKeyError;
+  if (useCases.includes("search") && appId) {
+    try {
+      const resolved2 = await resolveSearchOnlyKey(targetIndex, appId);
+      searchKey = resolved2.key;
+      summaries.push(
+        resolved2.source === "created" ? `Created a new search-only Algolia API key for the "${targetIndex}" index in app ${appId} \u2014 safe to expose in frontend code.` : `Reused the existing search-only Algolia API key for the "${targetIndex}" index in app ${appId}.`
+      );
+    } catch (err) {
+      searchKeyError = err.message;
+      summaries.push(
+        `Could not provision a search-only Algolia API key (${searchKeyError}) \u2014 the search agent will scaffold a placeholder with a TODO for you to fill in.`
+      );
+      logger.warn(
+        { err: searchKeyError },
+        "implement: could not provision a search-only API key; the agent will scaffold a placeholder"
+      );
+    }
+  }
   const input = {
     findings: normalized,
     confirmed: confirmed2,
     searchLocation,
     targetIndex,
     language,
-    publicEnvVarPrefix,
     appId,
-    searchEnvVars: publicSearchEnvVars(publicEnvVarPrefix, targetIndex, appId),
+    searchKey,
+    searchKeyError,
     ingestDir: INGEST_DIR,
     ingestionSource,
     uploadFilePath,
     searchUiTarget: searchUiTarget(language)
   };
-  const summaries = [];
-  if (uploadWarning) summaries.push(uploadWarning);
-  let envSearchKey;
-  let envAppIdMismatch = false;
-  if (useCases.includes("search") && appId) {
-    const envAppId = await readEnvVar(
-      repoRoot,
-      publicAppIdVar(publicEnvVarPrefix)
-    );
-    if (envAppId === appId) {
-      envSearchKey = await readEnvVar(
-        repoRoot,
-        publicSearchKeyVar(publicEnvVarPrefix)
-      );
-    } else if (envAppId) {
-      envAppIdMismatch = true;
-      const appIdVarName = publicAppIdVar(publicEnvVarPrefix);
-      const searchKeyVarName = publicSearchKeyVar(publicEnvVarPrefix);
-      summaries.push(
-        `\u26A0\uFE0F Your project's env files already set ${appIdVarName}=${envAppId}, but the active Algolia application is ${appId}. The wizard left those values alone \u2014 update ${appIdVarName} and ${searchKeyVarName} by hand, or searches will fail.`
-      );
-      logger.warn(
-        { envAppId, appId },
-        "implement: env files hold credentials for a different Algolia application; not reusing its search key"
-      );
-    }
-  }
-  let finalSearchEnvVars = input.searchEnvVars;
   let agentRuns = 0;
   let ingestCommand;
   let ingestScriptRan = false;
@@ -5196,6 +5107,7 @@ ${detail}` : ""}`
       ]
     });
   }
+  let searchConfigFile;
   if (useCases.includes("search")) {
     let extraInstructions = [];
     useWizard.getState().clearWrittenFiles();
@@ -5210,11 +5122,14 @@ ${detail}` : ""}`
           "implement: retrying search implementation after failed verification"
         );
       }
-      const { summary } = await runImplementationUseCase(
+      const searchResult = await runImplementationUseCase(
         "search",
         extraInstructions
       );
-      summaries.push(formatSummary("search", summary));
+      summaries.push(formatSummary("search", searchResult.summary));
+      if (searchResult.searchConfigFile) {
+        searchConfigFile = searchResult.searchConfigFile;
+      }
       const verification = await runVerificationUseCase();
       summaries.push(formatSummary("verification", verification.summary));
       if (verification.sufficient) {
@@ -5238,84 +5153,17 @@ ${detail}` : ""}`
       }
       extraInstructions = verificationRetryInstructions(verification);
     }
-    let searchKey;
-    let searchKeyError;
-    if (appId) {
-      try {
-        const resolved2 = await resolveSearchOnlyKey(
-          targetIndex,
-          appId,
-          envSearchKey
-        );
-        searchKey = resolved2.key;
-        summaries.push(
-          resolved2.source === "created" ? `Created a new search-only Algolia API key for the "${targetIndex}" index in app ${appId} \u2014 safe to expose in frontend code.` : `Reused the existing search-only Algolia API key for the "${targetIndex}" index in app ${appId}.`
-        );
-      } catch (err) {
-        searchKeyError = err.message;
-        logger.warn(
-          { err: searchKeyError },
-          "implement: could not provision a search-only API key; the env value stays a placeholder"
-        );
-      }
-    }
-    finalSearchEnvVars = publicSearchEnvVars(
-      publicEnvVarPrefix,
-      targetIndex,
-      appId,
-      searchKey
-    );
-    const resolvedSearchEnvVars = finalSearchEnvVars.filter(
-      (v) => !v.value.startsWith("<")
-    );
-    if (resolvedSearchEnvVars.length > 0) {
-      const defaultEnvFile = ENV_LOCAL_AWARE_PREFIXES.includes(
-        publicEnvVarPrefix
-      ) ? ".env.local" : ".env";
-      const written = await writeSearchEnvValues(
+    if (searchConfigFile) {
+      const ignoreStatus = await gitIgnoreStatus(
         repoRoot,
-        resolvedSearchEnvVars,
-        defaultEnvFile
+        join12(repoRoot, searchConfigFile)
       );
-      const writtenFiles = [...new Set(written.map((w) => w.file))];
-      for (const file of writtenFiles) {
-        const label = relative6(repoRoot, file);
-        const names = written.filter((w) => w.file === file).map((w) => w.name);
-        summaries.push(`Wrote ${names.join(", ")} to ${label}.`);
-        const ignored = await ensureGitIgnored(repoRoot, file);
-        if (ignored === "added") {
-          summaries.push(`Added ${label} to .gitignore.`);
-        } else if (ignored === "tracked") {
-          summaries.push(
-            `\u26A0\uFE0F ${label} is tracked by git, so a .gitignore rule cannot un-stage it. Run "git rm --cached ${label}" before committing, or the credentials go into history.`
-          );
-        }
-      }
-      const writtenNames = new Set(written.map((w) => w.name));
-      const stale = [];
-      for (const v of resolvedSearchEnvVars) {
-        if (writtenNames.has(v.name)) continue;
-        const current = await readEnvVar(repoRoot, v.name);
-        if (current && current !== v.value) stale.push(v);
-      }
-      if (stale.length > 0 && !envAppIdMismatch) {
+      if (ignoreStatus === "covered") {
         summaries.push(
-          `\u26A0\uFE0F Your project's env files already assign a different value to ${stale.map((v) => `${v.name} (should be ${v.value})`).join(", ")} \u2014 the wizard left it alone. Fix it by hand, or searches will fail.`
-        );
-        logger.warn(
-          { vars: stale.map((v) => v.name) },
-          "implement: env files hold different values for the resolved search credentials; not overwriting them"
+          `\u26A0\uFE0F ${searchConfigFile} is gitignored, so this public, safe-to-share search config won't reach teammates or CI. Remove whatever .gitignore rule covers it.`
         );
       }
     }
-    const unresolvedSearchEnvVars = finalSearchEnvVars.filter(
-      (v) => v.value.startsWith("<")
-    );
-    if (unresolvedSearchEnvVars.length > 0) {
-      summaries.push(
-        `Could not resolve a value for ${unresolvedSearchEnvVars.map((v) => v.name).join(", ")} \u2014 fill it in manually in .env or .env.local.` + (searchKeyError ? ` Reason: ${searchKeyError}` : "")
-      );
-    }
   } else {
     ctx.setUserInput("implementation", "success");
   }
@@ -5328,7 +5176,19 @@ ${detail}` : ""}`
       ...ingestRecordCount != null ? { ingestRecordCount } : {},
       ...ingestDurationMs != null ? { ingestDurationMs } : {}
     } : {},
-    ...useCases.includes("search") ? { searchEnvVars: finalSearchEnvVars } : {}
+    ...useCases.includes("search") ? {
+      searchConfig: {
+        filePath: searchConfigFile,
+        vars: [
+          { name: SEARCH_CONFIG_APP_ID, value: appId ?? "" },
+          {
+            name: SEARCH_CONFIG_SEARCH_KEY,
+            value: searchKey ?? SEARCH_KEY_PLACEHOLDER
+          },
+          { name: SEARCH_CONFIG_INDEX_NAME, value: targetIndex }
+        ]
+      }
+    } : {}
   };
 }
 
@@ -5368,8 +5228,8 @@ var defaultWorkflow = {
     defineStep({
       id: "select-index",
       title: "Set up index",
-      outputSchema: z30.object({
-        selection: z30.string()
+      outputSchema: z29.object({
+        selection: z29.string()
       }),
       run: (ctx) => selectIndexStep(ctx)
     }),
@@ -5477,10 +5337,14 @@ var confirmFramework2 = {
 var search = {
   summary: "Added an InstantSearch-powered search box and results list, mounted in the shared header component.",
   ingestionSource: "generated",
-  searchEnvVars: [
-    { name: "NEXT_PUBLIC_ALGOLIA_APP_ID", value: "SEEDAPPID" },
-    { name: "NEXT_PUBLIC_ALGOLIA_SEARCH_KEY", value: "seedsearchkey" }
-  ]
+  searchConfig: {
+    filePath: "src/algolia.config.ts",
+    vars: [
+      { name: "ALGOLIA_APP_ID", value: "SEEDAPPID" },
+      { name: "ALGOLIA_SEARCH_API_KEY", value: "seedsearchkey" },
+      { name: "ALGOLIA_INDEX_NAME", value: "wizard_seed_products" }
+    ]
+  }
 };
 var review = {
   summaryPoints: [
@@ -5647,7 +5511,7 @@ function parseCliArgs(argv) {
 
 // src/lib/resetState.ts
 import { readdir as readdir3, 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();
@@ -5661,7 +5525,7 @@ async function resetProjectState() {
   const targets = entries.filter((name) => !KEEP.includes(name));
   await Promise.all(
     targets.map(
-      (name) => rm2(join12(dir, name), { recursive: true, force: true })
+      (name) => rm2(join13(dir, name), { recursive: true, force: true })
     )
   );
   return { dir, removed: targets };

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

@@ -4,13 +4,18 @@ Install `instantsearch.js` (v4)
 
 ## Search client: always use the lite client
 
-Import the client from `algoliasearch/lite` and alias it to `algoliasearch`
+Import the client from `algoliasearch/lite` and alias it to `algoliasearch`.
+`ALGOLIA_APP_ID`, `ALGOLIA_SEARCH_API_KEY`, and `ALGOLIA_INDEX_NAME` below are
+the constants exported from the project's shared client-side config module —
+these are public values, safe to commit; never hardcode them inline or read
+them from an env var.
 
 ```ts
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
+import { ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY } from '<the project's shared config module>'
 
 // Instantiate ONCE, outside components, with a stable reference.
-const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 ```
 
 ## Vanilla (`instantsearch.js` v4)
@@ -19,11 +24,16 @@ const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
 import instantsearch from 'instantsearch.js'
 import { searchBox, hits } from 'instantsearch.js/es/widgets'
+import {
+  ALGOLIA_APP_ID,
+  ALGOLIA_SEARCH_API_KEY,
+  ALGOLIA_INDEX_NAME,
+} from '<the project's shared config module>'
 
-const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 
 const search = instantsearch({
-  indexName: 'INDEX_NAME',
+  indexName: ALGOLIA_INDEX_NAME,
   searchClient,
   insights: true,
 })
@@ -53,7 +63,7 @@ case, install `search-insights` from npm and pass its default export as
 import aa from 'search-insights'
 
 const search = instantsearch({
-  indexName: 'INDEX_NAME',
+  indexName: ALGOLIA_INDEX_NAME,
   searchClient,
   insights: { insightsClient: aa },
 })

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

@@ -4,13 +4,18 @@ Install `react-instantsearch` (v7)
 
 ## Search client: always use the lite client
 
-Import the client from `algoliasearch/lite` and alias it to `algoliasearch`
+Import the client from `algoliasearch/lite` and alias it to `algoliasearch`.
+`ALGOLIA_APP_ID`, `ALGOLIA_SEARCH_API_KEY`, and `ALGOLIA_INDEX_NAME` below are
+the constants exported from the project's shared client-side config module —
+these are public values, safe to commit; never hardcode them inline or read
+them from an env var.
 
 ```ts
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
+import { ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY } from '<the project's shared config module>'
 
 // Instantiate ONCE, outside components, with a stable reference.
-const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 ```
 
 ## React (`react-instantsearch` v7)
@@ -18,19 +23,19 @@ const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
 ```tsx
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
 import { InstantSearch, SearchBox, Hits } from 'react-instantsearch'
+import {
+  ALGOLIA_APP_ID,
+  ALGOLIA_SEARCH_API_KEY,
+  ALGOLIA_INDEX_NAME,
+} from '<the project's shared config module>'
 
-// Read from PUBLIC env vars; never hardcode. (Vite shown; use the framework's
-// convention: NEXT_PUBLIC_* for Next.js, etc.)
-const searchClient = algoliasearch(
-  import.meta.env.VITE_ALGOLIA_APP_ID,
-  import.meta.env.VITE_ALGOLIA_SEARCH_API_KEY,
-)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 
 export function Search() {
   return (
     <InstantSearch
       searchClient={searchClient}
-      indexName="INDEX_NAME"
+      indexName={ALGOLIA_INDEX_NAME}
       insights={true}
     >
       <SearchBox />

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

@@ -4,13 +4,18 @@ Install `vue-instantsearch` (v4)
 
 ## Search client: always use the lite client
 
-Import the client from `algoliasearch/lite` and alias it to `algoliasearch`
+Import the client from `algoliasearch/lite` and alias it to `algoliasearch`.
+`ALGOLIA_APP_ID`, `ALGOLIA_SEARCH_API_KEY`, and `ALGOLIA_INDEX_NAME` below are
+the constants exported from the project's shared client-side config module —
+these are public values, safe to commit; never hardcode them inline or read
+them from an env var.
 
 ```ts
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
+import { ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY } from '<the project's shared config module>'
 
 // Instantiate ONCE, outside components, with a stable reference.
-const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 ```
 
 ## Vue (`vue-instantsearch` v4)
@@ -19,7 +24,7 @@ const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
 <template>
   <ais-instant-search
     :search-client="searchClient"
-    index-name="INDEX_NAME"
+    :index-name="ALGOLIA_INDEX_NAME"
     :insights="true"
   >
     <ais-search-box />
@@ -29,11 +34,13 @@ const searchClient = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
 
 <script setup>
 import { liteClient as algoliasearch } from 'algoliasearch/lite'
+import {
+  ALGOLIA_APP_ID,
+  ALGOLIA_SEARCH_API_KEY,
+  ALGOLIA_INDEX_NAME,
+} from '<the project's shared config module>'
 
-const searchClient = algoliasearch(
-  import.meta.env.VITE_ALGOLIA_APP_ID,
-  import.meta.env.VITE_ALGOLIA_SEARCH_API_KEY,
-)
+const searchClient = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 </script>
 ```
 

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

@@ -5,10 +5,19 @@ route, or programmatic queries). For UI, prefer `instantsearch-setup-<framework>
 
 ## Client
 
+`ALGOLIA_APP_ID`, `ALGOLIA_SEARCH_API_KEY`, and `ALGOLIA_INDEX_NAME` below are
+the constants exported from the project's shared client-side config module —
+these are public values, safe to commit; never hardcode them inline or read
+them from an env var.
+
 ```ts
 import { algoliasearch } from 'algoliasearch'
+import {
+  ALGOLIA_APP_ID,
+  ALGOLIA_SEARCH_API_KEY,
+} from '<the project's shared config module>'
 
-const client = algoliasearch(APP_ID, SEARCH_ONLY_KEY)
+const client = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY)
 ```
 
 In v5 there is no `client.initIndex(...)`. Index methods take the index name as a
@@ -18,7 +27,7 @@ parameter on the client. Every method takes a single options object.
 
 ```ts
 const { hits, nbHits } = await client.searchSingleIndex({
-  indexName: 'INDEX_NAME',
+  indexName: ALGOLIA_INDEX_NAME,
   searchParams: { query: 'shoes', hitsPerPage: 20, page: 0 },
 })
 ```
@@ -28,7 +37,7 @@ const { hits, nbHits } = await client.searchSingleIndex({
 ```ts
 const { results } = await client.search({
   requests: [
-    { indexName: 'INDEX_NAME', query: 'shoes' },
+    { indexName: ALGOLIA_INDEX_NAME, query: 'shoes' },
     { indexName: 'OTHER_INDEX', query: 'shoes' },
   ],
 })

package/package.json

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