@algolia/wizard 0.19.0 → 0.20.0

package/dist/main.js

@@ -2246,7 +2246,7 @@ async function ensureApplication() {
 }
 
 // src/workflows/default.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/actions/listIndices.ts
 import { z as z5 } from "zod";
@@ -2767,6 +2767,28 @@ async function ensureGitIgnored(root, target) {
 var APP_ID_VAR = "ALGOLIA_APPLICATION_ID";
 var API_KEY_VAR = "ALGOLIA_WRITE_API_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}
@@ -3500,7 +3522,10 @@ async function runAgent(req) {
 import z21 from "zod";
 var detectLanguageSchema = z21.object({
   languages: z21.array(z21.object({ name: z21.string(), version: z21.string() })),
-  frameworks: z21.array(z21.object({ name: z21.string(), version: z21.string() }))
+  frameworks: z21.array(z21.object({ name: z21.string(), version: z21.string() })),
+  publicEnvVarPrefix: z21.string().regex(/^([A-Z0-9]+_)*$/).describe(
+    `The prefix a bundler/framework requires for an env var to reach client-side code (e.g. "NEXT_PUBLIC_", "VITE_", "NUXT_PUBLIC_"), uppercase with a trailing underscore when non-empty. Prefer the project's own existing convention over a framework default. Empty string when the project has no client-side env var exposure (e.g. a backend-only project).`
+  )
 });
 var detectLanguage = () => runAgent({
   instructions: [
@@ -3509,6 +3534,7 @@ var detectLanguage = () => runAgent({
     "If a meta-framework is used, exclude the framework it builds on (e.g. Next.js over React, Rails over Rack).",
     "Return the exact version",
     "Exclude things like CSS frameworks, build tools, or testing frameworks",
+    `Determine publicEnvVarPrefix: 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 the detected framework's known convention for exposing env vars to client-side code; use "" when the project has no such convention (e.g. a backend-only project).`,
     'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
     "When done, call reportStatus"
   ],
@@ -3604,7 +3630,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.19.0",
+  version: "0.20.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -4009,7 +4035,7 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 };
 
 // src/actions/implement.ts
-import z28 from "zod";
+import z29 from "zod";
 import { join as join12 } from "node:path";
 
 // src/lib/worktree.ts
@@ -4259,31 +4285,48 @@ function shellQuote(value) {
   return "'" + value.replace(/'/g, "'\\''") + "'";
 }
 
+// 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).`,
+    '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 = z28.object({
-  filesChanged: z28.array(z28.string()),
-  summary: z28.string(),
-  worktreePath: z28.string().optional(),
-  ingestCommand: z28.string().optional(),
-  ingestScriptRan: z28.boolean().optional(),
-  ingestRecordCount: z28.number().optional(),
-  ingestDurationMs: z28.number().optional(),
-  ingestionSource: z28.enum(["local", "fileUpload", "generated"]),
-  searchEnvVars: z28.array(
-    z28.object({
-      name: z28.string(),
-      value: z28.string()
+var implementSchema = z29.object({
+  filesChanged: z29.array(z29.string()),
+  summary: z29.string(),
+  worktreePath: z29.string().optional(),
+  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 implementationOutputSchema = z28.object({
-  summary: z28.string(),
-  ingestCommand: z28.string().optional()
+var implementationOutputSchema = z29.object({
+  summary: z29.string(),
+  ingestCommand: z29.string().optional()
 });
-var verificationOutputSchema = z28.object({
-  summary: z28.string(),
-  sufficient: z28.boolean(),
-  additionalInstructions: z28.string().optional()
+var verificationOutputSchema = z29.object({
+  summary: z29.string(),
+  sufficient: z29.boolean(),
+  additionalInstructions: z29.string().optional()
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
@@ -4314,53 +4357,6 @@ function searchUiTarget(language) {
 function frameworksForDoc(language) {
   return [matchUiFramework(language)?.doc ?? "js"];
 }
-function publicEnvPrefix(language) {
-  const frameworkNames = lower(language.frameworks);
-  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 isJsProject(language) ? "PUBLIC_" : "";
-}
-var APP_ID_VAR_SUFFIX = "ALGOLIA_APP_ID";
-var SEARCH_KEY_VAR_SUFFIX = "ALGOLIA_SEARCH_API_KEY";
-var INDEX_VAR_SUFFIX = "ALGOLIA_INDEX_NAME";
-function appIdVar(language) {
-  return `${publicEnvPrefix(language)}${APP_ID_VAR_SUFFIX}`;
-}
-function searchKeyVar(language) {
-  return `${publicEnvPrefix(language)}${SEARCH_KEY_VAR_SUFFIX}`;
-}
-function searchIndexVar(language) {
-  return `${publicEnvPrefix(language)}${INDEX_VAR_SUFFIX}`;
-}
-function searchEnvVars(language, index, appId, searchKey) {
-  return [
-    {
-      name: appIdVar(language),
-      value: appId ?? "<your-algolia-app-id>"
-    },
-    {
-      name: searchKeyVar(language),
-      value: searchKey ?? "<your-algolia-search-only-api-key>"
-    },
-    // Wizard-supplied rather than written into the generated code, because an
-    // agent that retypes the name (appending the project name, re-casing it)
-    // leaves the UI querying an index that does not exist.
-    {
-      name: searchIndexVar(language),
-      value: index
-    }
-  ];
-}
 function baseInstructions(input) {
   return [
     // Agents have renamed this (e.g. appending the project name), which the
@@ -4436,7 +4432,7 @@ function searchInstructions(input) {
     ],
     `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 search input and results list against the target index.`,
     "If a search box already exists, replace it with yours.",
-    `Read the index name from the ${searchIndexVar(input.language)} env var, which the wizard sets to "${input.targetIndex}". Never hardcode an index name or derive one from the project, file, or component name.`,
+    `Read the 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, so the agent never
     // sees one. It must also leave .env alone: the wizard reads that file to
@@ -4580,6 +4576,21 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     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"
   );
@@ -4667,14 +4678,20 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
         );
       }
     }
+    const publicEnvVarPrefix = await publicEnvVarPrefixPromise;
     const input = {
       findings: normalized,
       confirmed: confirmed2,
       searchLocation,
       targetIndex,
       language,
+      publicEnvVarPrefix,
       appId,
-      searchEnvVars: searchEnvVars(language, targetIndex, appId),
+      searchEnvVars: publicSearchEnvVars(
+        publicEnvVarPrefix,
+        targetIndex,
+        appId
+      ),
       ingestDir: INGEST_DIR,
       ingestionSource,
       uploadFilePath,
@@ -4685,13 +4702,21 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     let envSearchKey;
     let envAppIdMismatch = false;
     if (useCases.includes("search") && appId) {
-      const envAppId = await readEnvVar(worktree, appIdVar(language));
+      const envAppId = await readEnvVar(
+        worktree,
+        publicAppIdVar(publicEnvVarPrefix)
+      );
       if (envAppId === appId) {
-        envSearchKey = await readEnvVar(worktree, searchKeyVar(language));
+        envSearchKey = await readEnvVar(
+          worktree,
+          publicSearchKeyVar(publicEnvVarPrefix)
+        );
       } else if (envAppId) {
         envAppIdMismatch = true;
+        const appIdVarName = publicAppIdVar(publicEnvVarPrefix);
+        const searchKeyVarName = publicSearchKeyVar(publicEnvVarPrefix);
         summaries.push(
-          `\u26A0\uFE0F .env already sets ${appIdVar(language)}=${envAppId}, but the active Algolia application is ${appId}. The wizard left those values alone \u2014 update ${appIdVar(language)} and ${searchKeyVar(language)} by hand, or searches will fail.`
+          `\u26A0\uFE0F .env already sets ${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 },
@@ -4877,8 +4902,8 @@ ${detail}` : ""}`
           );
         }
       }
-      finalSearchEnvVars = searchEnvVars(
-        language,
+      finalSearchEnvVars = publicSearchEnvVars(
+        publicEnvVarPrefix,
         targetIndex,
         appId,
         searchKey
@@ -4990,8 +5015,8 @@ var defaultWorkflow = {
     defineStep({
       id: "select-index",
       title: "Set up index",
-      outputSchema: z29.object({
-        selection: z29.string()
+      outputSchema: z30.object({
+        selection: z30.string()
       }),
       run: (ctx) => selectIndexStep(ctx)
     }),
@@ -5063,6 +5088,7 @@ function getWorkflow(id) {
 var projectScan2 = {
   languages: [{ name: "TypeScript", version: "5.7.2" }],
   frameworks: [{ name: "Next.js", version: "15.1.0" }],
+  publicEnvVarPrefix: "NEXT_PUBLIC_",
   ingestionAnalysis: [
     {
       name: "Product",

package/package.json

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