@algolia/wizard 0.84.0-rc.202.644 → 0.84.0-rc.202.646

package/dist/main.js

@@ -2315,7 +2315,7 @@ async function ensureApplication(resumeAppId) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.84.0-rc.202.644",
+  version: "0.84.0-rc.202.646",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3739,7 +3739,7 @@ import { execFile as execFile2 } from "node:child_process";
 import { tool as tool8 } from "ai";
 import z15 from "zod";
 import { lstat as lstat3, readdir as readdir2, readFile as readFile8, realpath, stat as stat2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join8, relative as relative4, sep as sep2 } from "node:path";
+import { basename as basename2, isAbsolute as isAbsolute2, join as join8, relative as relative4, sep as sep2 } from "node:path";
 import { performance } from "node:perf_hooks";
 import { Worker } from "node:worker_threads";
 var MAX_GIT_OUTPUT_BYTES = 32e6;
@@ -4082,6 +4082,9 @@ async function safeSearchPath(rootPath, file) {
 }
 async function searchableFiles(root, target) {
   try {
+    if (SKIP_FILES.has(basename2(target)) && (await lstat3(target)).isFile()) {
+      return [target];
+    }
     const gitRoot = await gitRootForTarget(root, target);
     const result = await gitVisibleFiles(gitRoot, target);
     return result.available ? expandNestedRepositories(result.files) : walkFiles(root, target);
@@ -4113,7 +4116,7 @@ function searchFilesTool(ctx) {
     description: "Search file contents for a JavaScript regular expression (RegExp syntax, not grep/PCRE). Returns matching lines as file:line:text.",
     inputSchema: z15.object({
       query: z15.string().describe("JavaScript RegExp pattern to search for"),
-      path: z15.string().optional().describe("Directory to search in (default: cwd)")
+      path: z15.string().optional().describe("Directory or file to search in (default: cwd)")
     }),
     execute: async ({ query, path = "." }) => {
       logger.info({ query, path }, "called searchFiles tool");
@@ -4258,7 +4261,7 @@ import { tool as tool9 } from "ai";
 import z16 from "zod";
 import { createHash as createHash2 } from "node:crypto";
 import { readFile as readFile9, stat as stat3 } from "node:fs/promises";
-import { basename as basename2, relative as relative5, resolve as resolve3 } from "node:path";
+import { basename as basename3, relative as relative5, resolve as resolve3 } from "node:path";
 
 // src/lib/tools/utils/prompt.ts
 var chain = Promise.resolve();
@@ -4356,7 +4359,7 @@ function commandDiffersFromReviewedScript(ctx, command, cwd) {
   if (approval.command === command && approval.cwd === cwd) return false;
   if (approval.command === command) return true;
   const scriptReferences = [
-    basename2(approval.filePath),
+    basename3(approval.filePath),
     relative5(ctx.root, approval.filePath),
     ".algolia-wizard"
   ];
@@ -6009,7 +6012,7 @@ import {
 // src/lib/git.ts
 import { execFile as execFile3 } from "node:child_process";
 import { copyFile, mkdir as mkdir4, stat as stat4 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname3, isAbsolute as isAbsolute3, join as join9, resolve as resolve4 } from "node:path";
+import { basename as basename4, dirname as dirname3, isAbsolute as isAbsolute3, join as join9, resolve as resolve4 } from "node:path";
 var MAX_BUFFER = 32 * 1024 * 1024;
 function git(args) {
   return new Promise((resolve6, reject) => {
@@ -6046,7 +6049,7 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
   } catch {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
-  const relPath = join9(ingestDir, basename3(source));
+  const relPath = join9(ingestDir, basename4(source));
   const dest = join9(repoRoot, relPath);
   if (resolve4(source) === resolve4(dest)) {
     return { ok: true, relPath };
@@ -6193,6 +6196,11 @@ var INGESTION_SOURCE = {
 var BUILD_CHECK_PROMPT = "Run type-check now? This can take several minutes on a large repository.";
 var MISSING_DEPENDENCIES_PROMPT = "Dependencies are not installed. Install them and run type-check now?";
 var UNRELATED_FAILURE_PROMPT = "These checks are still failing and appear unrelated to the changes. Continue the investigation?";
+var INGEST_RETRY_PROMPT = "Fix the cause (for example, start the database the script reads from), then retry.";
+var INGEST_RETRY = {
+  retry: "Retry ingestion",
+  skip: "Continue without records"
+};
 var FILE_UPLOAD_PATH_PROMPT = "Enter the path to your JSON, CSV, or TSV file (relative to the project root, or absolute):";
 var JS_LANGUAGES = ["javascript", "typescript", "jsx", "tsx", "node"];
 function lower(entries) {
@@ -6295,6 +6303,7 @@ function ingestionInstructions(input) {
       ] : [],
       `When the script is finished, decide the exact command and cwd you will use to run it. Make sure that the script path in the command resolves from that cwd to the filePath. Then call reviewScript with that filePath, command, cwd, the exact selected entityName, and usesGeneratedRecords set to ${input.ingestionSource === "generated"}. Wait for the developer to review it because running it writes records to a live index. Do not run it before that call returns. If you change the command or cwd after a failed run, call reviewScript again before runShell.`,
       'Then, without changing directories, run the script yourself via runShell using the exact same command and cwd. 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.',
+      "When the script reads from a database or another service, find how the project connects to it locally (env files, README, socket or TCP settings). If that connection needs a local service, such as a database proxy (for example cloud-sql-proxy) or a tunnel, make the script check the connection before it reads, and exit with an error that names the service and the command from the project docs that starts it.",
       "If external data access fails, do not run authentication commands, change accounts or machine configuration, or start proxies, containers, or services.",
       "Do not troubleshoot unavailable external infrastructure. Preserve the script and command, report success, and let the developer prepare the data source.",
       "If the script cannot access an external data source because credentials or a service are unavailable, do not report status=fail. Report status=success with the completed script, ingestCommand, and a concise failure summary. The wizard handles this run failure and tells the developer how to retry.",
@@ -6427,6 +6436,7 @@ function validationInstructions(input) {
     "Inspect the CSS that actually applies to the generated DOM. Confirm the results panel and the element drawing the input frame have non-transparent surfaces, the input frame is distinguishable from its surrounding background in every supported theme, text meets 4.5:1 contrast, meaningful boundaries and focus indicators meet 3:1, and no state relies on color alone.",
     "Confirm the search experience reflows without horizontal page scrolling at 320 CSS pixels, keeps its panel on-screen, preserves visible focus, and respects reduced-motion preferences for any added animation.",
     "If the project imports an InstantSearch theme and overrides its palette, confirm that the palette overrides (--ais-*-rgb) win over the theme: they must use a higher specificity than the theme, for example `:root:root`, and for a dark mode `:root:root.dark` or `:root:root[data-theme=dark]`, because the theme sets its own blue in `:root` and in `:root[data-theme=dark], .dark`. `:root:root` alone ties with `:root[data-theme=dark]`. If an override can lose to the theme, set sufficient=false, because the search icon and focus ring then show the theme blue instead of the app accent color.",
+    "Find how the app selects each theme it supports (a class or attribute on an ancestor, a prefers-color-scheme media query, or a theme that exists only in code). Confirm that the search input and results panel take their colors from the active app theme through that same switch. A search widget whose colors do not match the page theme, for example a light panel on a dark page, is a failure: set sufficient=false.",
     "When the project has a package.json, confirm that the theme CSS of the search widget (for InstantSearch, a theme from instantsearch.css) is imported once, from the component or the global stylesheet. If it is installed but not imported, set sufficient=false.",
     "Confirm that the search component is reachable from and fits the corresponding content task at every supported breakpoint; require app-wide reachability only when the search scope is genuinely app-wide.",
     "Do not run the test suite or any test command.",
@@ -6596,6 +6606,22 @@ function ingestFailure(attempt, executions) {
   }
   return { reason: `it failed (exit ${attempt.exitCode ?? "unknown"})`, detail };
 }
+function errorLine(output) {
+  const lines = output?.split("\n").map((l) => l.trim()).filter(Boolean) ?? [];
+  return [...lines].reverse().find((l) => /\w*(Error|Exception)\b/.test(l)) ?? lines.at(-1);
+}
+function ingestFailureMessages(headline, detail, command, cwd) {
+  return [
+    headline,
+    // One message per line: Notices.tsx counts a message as one wrapped
+    // line, so an embedded newline overflows the panel's height accounting.
+    ...detail?.split("\n").filter((l) => l.trim()) ?? [],
+    ...command ? [
+      `Ingestion command: ${command}`,
+      ...cwd !== "." ? [`Working directory: ${cwd}`] : []
+    ] : []
+  ];
+}
 function makeToolContext(root, appId, env = async () => ({}), secretEnv = async () => ({})) {
   return {
     ...createToolContext(
@@ -6903,11 +6929,45 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     ingestCommand = result.ingestCommand;
     const ingestionContext = ingestionTools;
     const executions = ingestionContext.shell.executions;
+    let outcome = ingestOutcome(executions, repoRoot, ingestCommand);
+    let failureAcknowledged = false;
+    while (!outcome.run && outcome.attempt?.approved) {
+      const attempt = outcome.attempt;
+      const { reason, detail } = ingestFailure(attempt, executions);
+      const choice = await ctx.requestUserInput({
+        prompt: INGEST_RETRY_PROMPT,
+        promptType: "multipleChoice",
+        options: [INGEST_RETRY.retry, INGEST_RETRY.skip],
+        messages: ingestFailureMessages(
+          `\u26A0\uFE0F Records were not indexed \u2014 ${reason}.`,
+          errorLine(detail),
+          attempt.command,
+          relativeIngestCwd(attempt, repoRoot)
+        )
+      });
+      if (choice !== INGEST_RETRY.retry) {
+        failureAcknowledged = true;
+        break;
+      }
+      const rerun = await runReviewedCommand(
+        ingestionContext,
+        attempt.command,
+        attempt.cwd
+      );
+      if (rerun === void 0 || typeof rerun === "string") {
+        logger.warn(
+          { command: attempt.command, refusal: rerun },
+          "implement: could not retry the ingestion command"
+        );
+        break;
+      }
+      outcome = ingestOutcome(executions, repoRoot, ingestCommand);
+    }
     const {
       run: ingestRun,
       attempt: ingestAttempt,
       recordCount
-    } = ingestOutcome(executions, repoRoot, ingestCommand);
+    } = outcome;
     let ingestCwd = ".";
     if (ingestAttempt) {
       ingestCommand = ingestAttempt.command;
@@ -6987,22 +7047,17 @@ ${detail}` : ""}`
           "When you're ready to continue, we'll move on to search implementation."
         ]
       });
-    } else {
-      const commandMessages = ingestCommand ? [
-        `Ingestion command: ${ingestCommand}`,
-        ...ingestCwd !== "." ? [`Working directory: ${ingestCwd}`] : []
-      ] : [];
+    } else if (!failureAcknowledged) {
       await ctx.requestUserInput({
         prompt: "",
         promptType: "enterToContinue",
         options: [],
-        // One message per line: Notices.tsx counts a message as one wrapped
-        // line, so an embedded newline overflows the panel's height accounting.
-        messages: [
+        messages: ingestFailureMessages(
           ingestOutcomeMessage,
-          ...ingestFailureDetail?.split("\n").filter((l) => l.trim()) ?? [],
-          ...commandMessages
-        ]
+          ingestFailureDetail,
+          ingestCommand,
+          ingestCwd
+        )
       });
     }
   }
@@ -9270,7 +9325,7 @@ async function resetProjectState() {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.84.0-rc.202.644",
+  version: "0.84.0-rc.202.646",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

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

@@ -160,6 +160,25 @@ above). When the app has a dark mode, also override the dark values with `:root:
 a dark class or `:root:root[data-theme=dark]` for a `data-theme` attribute: `:root:root` alone
 ties with `:root[data-theme=dark]`. The override then wins whatever the import order. Then check that the search icon has the app's accent color, not the theme blue.
 
+**Follow the app's theme switch.** The theme switches palette only through `:root[data-theme=dark], .dark`,
+so find how the app selects each theme and set the `--ais-*-rgb` values through the same switch:
+
+- A class or attribute on an ancestor: override under that selector, as above.
+- A `prefers-color-scheme` media query: override inside the same query, for example
+  `@media (prefers-color-scheme: dark) { :root:root { … } }`.
+- A theme that exists only in code (a theme object, a theme store), with no class or attribute
+  on the page: set the values from that theme as inline custom properties on the widget
+  container, and set them again when the theme changes.
+
+The panel renders inside the widget, so values on the container apply to the whole widget. Make
+triplets from opaque theme colors, because a triplet has no alpha:
+
+```js
+container.style.setProperty('--ais-background-color-rgb', toRgbTriplet(theme.surface))
+```
+
+Then check the input and the panel in each theme that the app supports.
+
 Everything else is plain CSS against the widget's classes, or `cssClasses` /
 `indices[].cssClasses` to add your own names to the same elements. Who owns what:
 

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

@@ -152,6 +152,25 @@ above). When the app has a dark mode, also override the dark values with `:root:
 a dark class or `:root:root[data-theme=dark]` for a `data-theme` attribute: `:root:root` alone
 ties with `:root[data-theme=dark]`. The override then wins whatever the import order. Then check that the search icon has the app's accent color, not the theme blue.
 
+**Follow the app's theme switch.** The theme switches palette only through `:root[data-theme=dark], .dark`,
+so find how the app selects each theme and set the `--ais-*-rgb` values through the same switch:
+
+- A class or attribute on an ancestor: override under that selector, as above.
+- A `prefers-color-scheme` media query: override inside the same query, for example
+  `@media (prefers-color-scheme: dark) { :root:root { … } }`.
+- A theme that exists only in code (a theme object, a CSS-in-JS provider, a theme store), with
+  no class or attribute on the page: set the values from that theme as inline custom properties
+  on the element that wraps the widget, so they follow theme changes.
+
+The panel renders inside the widget, so values on a wrapper apply to the whole widget. Make
+triplets from opaque theme colors, because a triplet has no alpha:
+
+```tsx
+<search style={{ '--ais-background-color-rgb': toRgbTriplet(theme.surface) } as React.CSSProperties}>
+```
+
+Then check the input and the panel in each theme that the app supports.
+
 Everything else is plain CSS against the widget's classes, or the `classNames` /
 `indices[].classNames` props to add your own names to the same elements. Who owns what:
 

package/package.json

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