@algolia/wizard 0.81.0 → 0.83.0

package/dist/main.js

@@ -2306,7 +2306,7 @@ async function ensureApplication(resumeAppId) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.81.0",
+  version: "0.83.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3566,30 +3566,379 @@ async function gitIgnoreOutcome(ctx, target) {
 }
 
 // src/lib/tools/searchFiles.ts
+import { execFile as execFile2 } from "node:child_process";
 import { tool as tool7 } from "ai";
 import z14 from "zod";
-import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { lstat as lstat3, readdir as readdir2, readFile as readFile7, 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 { performance } from "node:perf_hooks";
+import { Worker } from "node:worker_threads";
+var MAX_GIT_OUTPUT_BYTES = 32e6;
 var MAX_QUERY_LENGTH = 1e3;
+var MAX_MATCH_TEXT_CHARACTERS = 500;
+var MAX_RESULT_CHARACTERS = 32e3;
+var REGEX_TIMEOUT_MS = 100;
+var REGEX_SEARCH_DEADLINE_MS = 2e3;
+var LINE_NUMBER_OFFSET = 1;
+var NEWLINE_CHARACTER_COUNT = 1;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
   "build",
+  "coverage",
   "vendor",
   "venv",
   "__pycache__",
   "target"
 ]);
-async function walkFiles(dir) {
+var SKIP_FILES = /* @__PURE__ */ new Set([
+  "bun.lock",
+  "bun.lockb",
+  "Cargo.lock",
+  "composer.lock",
+  "Gemfile.lock",
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "Pipfile.lock",
+  "Podfile.lock",
+  "pnpm-lock.yaml",
+  "poetry.lock",
+  "uv.lock",
+  "yarn.lock"
+]);
+var REGEX_WORKER_SOURCE = `
+const { parentPort, workerData } = require('node:worker_threads')
+
+function matchingLineSnippet(line, matchIndex) {
+  if (line.length <= workerData.maxMatchTextCharacters) return line
+
+  const contextBefore = Math.floor(workerData.maxMatchTextCharacters / 2)
+  const start = Math.max(0, matchIndex - contextBefore)
+  const end = Math.min(
+    line.length,
+    start + workerData.maxMatchTextCharacters,
+  )
+  const prefix = start > 0 ? '... ' : ''
+  const suffix = end < line.length ? ' ...' : ''
+  return \`\${prefix}\${line.slice(start, end)}\${suffix} (line truncated)\`
+}
+
+let expression
+try {
+  expression = new RegExp(workerData.query)
+} catch (error) {
+  parentPort.postMessage({
+    type: 'invalid',
+    message: error instanceof Error ? error.message : String(error),
+  })
+  parentPort.close()
+}
+
+if (expression !== undefined) {
+  parentPort.postMessage({ type: 'ready' })
+  parentPort.on('message', ({ id, content, limit }) => {
+    const matches = []
+    const lines = content.split('\\n')
+    parentPort.postMessage({ type: 'started', id })
+    for (const [lineIndex, line] of lines.entries()) {
+      const matchIndex = line.search(expression)
+      if (matchIndex >= 0) {
+        matches.push({
+          lineIndex,
+          text: matchingLineSnippet(line, matchIndex),
+        })
+        if (matches.length >= limit) break
+      }
+    }
+    parentPort.postMessage({ type: 'matches', id, matches })
+  })
+}
+`;
+var InvalidRegexError = class extends Error {
+};
+var RegexSearchWorker = class _RegexSearchWorker {
+  worker;
+  ready;
+  resolveReady;
+  rejectReady;
+  readySettled = false;
+  stopped = false;
+  nextId = 0;
+  pending;
+  termination;
+  constructor(query) {
+    this.ready = new Promise((resolve6, reject) => {
+      this.resolveReady = resolve6;
+      this.rejectReady = reject;
+    });
+    this.worker = new Worker(REGEX_WORKER_SOURCE, {
+      eval: true,
+      workerData: {
+        query,
+        maxMatchTextCharacters: MAX_MATCH_TEXT_CHARACTERS
+      }
+    });
+    this.worker.on("message", (message) => {
+      this.handleMessage(message);
+    });
+    this.worker.on("error", this.handleWorkerError);
+    this.worker.on("exit", (code) => {
+      if (this.termination === void 0 && !this.stopped) {
+        this.fail(new Error(`Regex worker exited unexpectedly with code ${code}`));
+      }
+    });
+  }
+  static async create(query) {
+    const searchWorker = new _RegexSearchWorker(query);
+    try {
+      await searchWorker.ready;
+      return searchWorker;
+    } catch (error) {
+      await searchWorker.close();
+      throw error;
+    }
+  }
+  match(content, limit, timeoutMs) {
+    if (this.stopped) throw new Error("Regex worker is not available");
+    return new Promise((resolve6, reject) => {
+      const id = ++this.nextId;
+      const pending = { id, timeoutMs, resolve: resolve6, reject };
+      this.pending = pending;
+      try {
+        this.worker.postMessage({ id, content, limit });
+      } catch (error) {
+        this.pending = void 0;
+        reject(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+    });
+  }
+  async close() {
+    this.stopped = true;
+    const pending = this.pending;
+    if (pending?.timer !== void 0) clearTimeout(pending.timer);
+    this.termination ??= this.worker.terminate();
+    await this.termination.catch(() => void 0);
+  }
+  handleWorkerError = (error) => {
+    this.fail(error);
+  };
+  handleMessage(message) {
+    if (message.type === "ready") {
+      if (!this.readySettled) {
+        this.readySettled = true;
+        this.resolveReady();
+      }
+      return;
+    }
+    if (message.type === "invalid") {
+      if (!this.readySettled) {
+        this.readySettled = true;
+        this.stopped = true;
+        this.rejectReady(
+          new InvalidRegexError(message.message ?? "Invalid regular expression")
+        );
+      }
+      return;
+    }
+    const pending = this.pending;
+    if (message.type === "started" && message.id !== void 0 && pending !== void 0 && pending.id === message.id) {
+      const startedAt = performance.now();
+      pending.startedAt = startedAt;
+      pending.timer = setTimeout(() => {
+        const current = this.pending;
+        if (current === void 0 || current.id !== message.id) return;
+        this.pending = void 0;
+        this.stopped = true;
+        this.termination = this.worker.terminate();
+        pending.resolve({
+          locations: null,
+          executionMs: performance.now() - startedAt
+        });
+      }, pending.timeoutMs);
+      return;
+    }
+    if (message.type !== "matches" || message.id === void 0 || message.matches === void 0 || pending === void 0 || pending.id !== message.id || pending.startedAt === void 0) {
+      return;
+    }
+    this.pending = void 0;
+    if (pending.timer !== void 0) clearTimeout(pending.timer);
+    pending.resolve({
+      locations: message.matches,
+      executionMs: performance.now() - pending.startedAt
+    });
+  }
+  fail(error) {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (!this.readySettled) {
+      this.readySettled = true;
+      this.rejectReady(error);
+    }
+    const pending = this.pending;
+    this.pending = void 0;
+    if (pending !== void 0) {
+      if (pending.timer !== void 0) clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+  }
+};
+function isSearchableGitPath(path, skipGeneratedDirs) {
+  const parts = path.split("/");
+  const fileName = path.slice(path.lastIndexOf("/") + LINE_NUMBER_OFFSET);
+  return !SKIP_FILES.has(fileName) && parts.every(
+    (part) => !part.startsWith(".") && (!skipGeneratedDirs || !SKIP_DIRS.has(part))
+  );
+}
+function parseGitFiles(root, output, skipGeneratedDirs) {
+  return output.split("\0").filter(Boolean).filter((path) => isSearchableGitPath(path, skipGeneratedDirs)).map((path) => join8(root, path));
+}
+function gitIsUnavailable(error, stderr) {
+  return "code" in error && error.code === "ENOENT" || stderr.includes("not a git repository");
+}
+async function listGitFiles(root, pathspec, args, skipGeneratedDirs) {
+  const env = { ...process.env };
+  env.GIT_DIR = void 0;
+  env.GIT_WORK_TREE = void 0;
+  env.GIT_INDEX_FILE = void 0;
+  env.GIT_OBJECT_DIRECTORY = void 0;
+  env.GIT_COMMON_DIR = void 0;
+  return new Promise((resolve6, reject) => {
+    execFile2(
+      "git",
+      ["-C", root, "ls-files", ...args, "-z", "--", pathspec],
+      { env, maxBuffer: MAX_GIT_OUTPUT_BYTES },
+      (error, stdout, stderr) => {
+        if (error === null) {
+          resolve6({
+            available: true,
+            files: parseGitFiles(
+              root,
+              stdout.toString(),
+              skipGeneratedDirs
+            )
+          });
+          return;
+        }
+        if (gitIsUnavailable(error, stderr.toString())) {
+          resolve6({ available: false, files: [] });
+          return;
+        }
+        reject(error);
+      }
+    );
+  });
+}
+async function gitVisibleFiles(root, target) {
+  const pathspec = relative4(root, target).split(sep2).join("/") || ".";
+  const [tracked, untracked] = await Promise.all([
+    listGitFiles(root, pathspec, ["--cached"], false),
+    listGitFiles(
+      root,
+      pathspec,
+      ["--others", "--exclude-standard"],
+      true
+    )
+  ]);
+  if (!tracked.available || !untracked.available) {
+    return { available: false, files: [] };
+  }
+  return {
+    available: true,
+    files: [.../* @__PURE__ */ new Set([...tracked.files, ...untracked.files])]
+  };
+}
+function isInsideRoot(root, target) {
+  const fromRoot = relative4(root, target);
+  return fromRoot !== ".." && !fromRoot.startsWith(`..${sep2}`) && !isAbsolute2(fromRoot);
+}
+async function walkFiles(root, dir) {
+  const [rootPath, dirPath, dirInfo] = await Promise.all([
+    realpath(root),
+    realpath(dir),
+    lstat3(dir)
+  ]);
+  if (dirInfo.isSymbolicLink() || !isInsideRoot(rootPath, dirPath)) {
+    return [];
+  }
   const out = [];
   for (const e of await readdir2(dir, { withFileTypes: true })) {
     if (e.name.startsWith(".") || SKIP_DIRS.has(e.name)) continue;
     const full = join8(dir, e.name);
-    if (e.isDirectory()) out.push(...await walkFiles(full));
-    else if (e.isFile()) out.push(full);
+    if (e.isDirectory()) out.push(...await walkFiles(root, full));
+    else if (e.isFile() && !SKIP_FILES.has(e.name)) out.push(full);
   }
   return out;
 }
+async function expandNestedRepositories(files) {
+  const expanded = [];
+  for (const file of files) {
+    const info = await lstat3(file).catch(() => null);
+    if (info?.isFile() || info?.isSymbolicLink()) {
+      expanded.push(file);
+      continue;
+    }
+    if (!info?.isDirectory()) continue;
+    try {
+      const nested = await gitVisibleFiles(file, file);
+      expanded.push(
+        ...nested.available ? nested.files : await walkFiles(file, file)
+      );
+    } catch (error) {
+      logger.warn(
+        { error, root: file },
+        "searchFiles: nested Git file scan failed, using safe walker"
+      );
+      expanded.push(...await walkFiles(file, file));
+    }
+  }
+  return expanded;
+}
+async function gitRootForTarget(root, target) {
+  let repositoryRoot = root;
+  let current = root;
+  const parts = relative4(root, target).split(sep2).filter(Boolean);
+  for (const part of parts) {
+    current = join8(current, part);
+    const info = await lstat3(current).catch(() => null);
+    if (!info?.isDirectory()) return repositoryRoot;
+    const marker = await lstat3(join8(current, ".git")).catch(() => null);
+    if (marker?.isDirectory() || marker?.isFile()) repositoryRoot = current;
+  }
+  return repositoryRoot;
+}
+async function safeSearchPath(rootPath, file) {
+  const [info, filePath] = await Promise.all([lstat3(file), realpath(file)]);
+  return info.isFile() && isInsideRoot(rootPath, filePath) ? filePath : null;
+}
+async function searchableFiles(root, target) {
+  try {
+    const gitRoot = await gitRootForTarget(root, target);
+    const result = await gitVisibleFiles(gitRoot, target);
+    return result.available ? expandNestedRepositories(result.files) : walkFiles(root, target);
+  } catch (error) {
+    logger.warn(
+      { error, root, target },
+      "searchFiles: Git file scan failed, using safe walker"
+    );
+    return walkFiles(root, target);
+  }
+}
+function formatSearchResult(matches, skippedFiles, deadlineReached, workerFailed, finalMarker) {
+  const lines = [...matches];
+  if (skippedFiles > 0) {
+    const fileLabel = skippedFiles === 1 ? "file" : "files";
+    const deadlineMarker = deadlineReached ? ", regex deadline reached" : "";
+    lines.push(
+      `... (partial results: skipped ${skippedFiles} timed-out ${fileLabel}${deadlineMarker})`
+    );
+  }
+  if (workerFailed) {
+    lines.push("... (partial results: regex worker stopped unexpectedly)");
+  }
+  if (finalMarker !== void 0) lines.push(finalMarker);
+  return lines.length > 0 ? lines.join("\n") : "No matches";
+}
 function searchFilesTool(ctx) {
   return tool7({
     description: "Search file contents for a JavaScript regular expression (RegExp syntax, not grep/PCRE). Returns matching lines as file:line:text.",
@@ -3607,32 +3956,124 @@ function searchFilesTool(ctx) {
       }
       const resolved2 = resolveInRoot(ctx, path);
       if (!resolved2.ok) return resolved2.error;
-      let re;
       try {
-        re = new RegExp(query);
+        await stat2(resolved2.target);
       } catch (err) {
-        return `Invalid regex: ${err.message}`;
+        return `Error searching ${path}: ${err.message}`;
+      }
+      let regexWorker;
+      try {
+        regexWorker = await RegexSearchWorker.create(query);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (error instanceof InvalidRegexError) {
+          return `Invalid regex: ${message}`;
+        }
+        logger.warn({ error }, "searchFiles: regex worker failed to start");
+        return "Refused: regex worker could not start. Retry the search.";
       }
       const matches = [];
-      for (const file of await walkFiles(resolved2.target)) {
-        let content;
+      let resultCharacters = 0;
+      let skippedFiles = 0;
+      let remainingRegexTime = REGEX_SEARCH_DEADLINE_MS;
+      let deadlineReached = false;
+      let workerFailed = false;
+      try {
         try {
-          content = await readFile7(file, "utf8");
-        } catch {
-          continue;
-        }
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-          if (re.test(lines[i])) {
-            matches.push(`${file}:${i + 1}:${lines[i]}`);
-            if (matches.length >= ctx.limits.match) {
-              matches.push(`... (truncated at ${ctx.limits.match} matches)`);
-              return matches.join("\n");
+          const files = await searchableFiles(ctx.root, resolved2.target);
+          const rootPath = await realpath(ctx.root);
+          for (const [fileIndex, file] of files.entries()) {
+            const moreFilesRemain = fileIndex < files.length - LINE_NUMBER_OFFSET;
+            if (remainingRegexTime <= 0) {
+              deadlineReached = true;
+              break;
+            }
+            let content;
+            try {
+              const filePath = await safeSearchPath(rootPath, file);
+              if (filePath === null) continue;
+              content = await readFile7(filePath, "utf8");
+            } catch {
+              continue;
+            }
+            let result;
+            try {
+              result = await regexWorker.match(
+                content,
+                ctx.limits.match - matches.length,
+                Math.min(REGEX_TIMEOUT_MS, remainingRegexTime)
+              );
+            } catch (error) {
+              logger.warn(
+                { error, file },
+                "searchFiles: regex worker stopped during search"
+              );
+              workerFailed = true;
+              break;
+            }
+            const { executionMs, locations } = result;
+            remainingRegexTime -= executionMs;
+            if (locations === null) {
+              skippedFiles += LINE_NUMBER_OFFSET;
+              if (!moreFilesRemain) break;
+              if (remainingRegexTime <= 0) {
+                deadlineReached = true;
+                break;
+              }
+              await regexWorker.close();
+              try {
+                regexWorker = await RegexSearchWorker.create(query);
+              } catch (error) {
+                logger.warn(
+                  { error, file },
+                  "searchFiles: regex worker failed to restart"
+                );
+                workerFailed = true;
+                break;
+              }
+              continue;
+            }
+            for (const { lineIndex, text } of locations) {
+              const lineNumber = lineIndex + LINE_NUMBER_OFFSET;
+              const match = `${file}:${lineNumber}:${text}`;
+              const nextResultCharacters = resultCharacters + match.length + NEWLINE_CHARACTER_COUNT;
+              if (nextResultCharacters > MAX_RESULT_CHARACTERS) {
+                matches.push(
+                  `... (truncated at ${MAX_RESULT_CHARACTERS} characters)`
+                );
+                return formatSearchResult(
+                  matches,
+                  skippedFiles,
+                  deadlineReached,
+                  workerFailed
+                );
+              }
+              matches.push(match);
+              resultCharacters = nextResultCharacters;
+              if (matches.length >= ctx.limits.match) {
+                return formatSearchResult(
+                  matches,
+                  skippedFiles,
+                  deadlineReached,
+                  workerFailed,
+                  `... (truncated at ${ctx.limits.match} matches)`
+                );
+              }
             }
           }
+        } catch (error) {
+          logger.warn({ error }, "searchFiles: safe file scan failed");
+          return "Refused: Could not list searchable files safely. Fix file access and retry.";
         }
+      } finally {
+        await regexWorker.close();
       }
-      return matches.length ? matches.join("\n") : "No matches";
+      return formatSearchResult(
+        matches,
+        skippedFiles,
+        deadlineReached,
+        workerFailed
+      );
     }
   });
 }
@@ -3641,14 +4082,14 @@ function searchFilesTool(ctx) {
 import { tool as tool9, generateText, Output } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import z16 from "zod";
-import { relative as relative5 } from "node:path";
+import { relative as relative6 } from "node:path";
 
 // src/lib/tools/reviewScript.ts
 import { tool as tool8 } from "ai";
 import z15 from "zod";
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile8, stat as stat2 } from "node:fs/promises";
-import { basename as basename2, relative as relative4, resolve as resolve3 } from "node:path";
+import { readFile as readFile8, stat as stat3 } from "node:fs/promises";
+import { basename as basename2, relative as relative5, resolve as resolve3 } from "node:path";
 
 // src/lib/tools/utils/prompt.ts
 var chain = Promise.resolve();
@@ -3747,7 +4188,7 @@ function commandDiffersFromReviewedScript(ctx, command, cwd) {
   if (approval.command === command) return true;
   const scriptReferences = [
     basename2(approval.filePath),
-    relative4(ctx.root, approval.filePath),
+    relative5(ctx.root, approval.filePath),
     ".algolia-wizard"
   ];
   return scriptReferences.some(
@@ -3796,19 +4237,19 @@ function reviewScriptTool(ctx) {
       if (resolved2.ok === false) return resolved2.error;
       const resolvedCwd = resolveInRoot(ctx, cwd);
       if (resolvedCwd.ok === false) return resolvedCwd.error;
-      const displayCwd = relative4(ctx.root, resolvedCwd.target) || ".";
-      const displayFilePath = relative4(ctx.root, resolved2.target);
+      const displayCwd = relative5(ctx.root, resolvedCwd.target) || ".";
+      const displayFilePath = relative5(ctx.root, resolved2.target);
       const ingestionSummary = usesGeneratedRecords ? `This will push ${entityName} records from generated sample data to Algolia. You can replace the sample dataset with your real data source in ${displayFilePath}.` : `This will push ${entityName} records from your selected source to Algolia.`;
       return serializePrompt(async () => {
         revokeCommandApprovals(ctx, command, resolvedCwd.target);
-        const isFile = await stat2(resolved2.target).then(
+        const isFile = await stat3(resolved2.target).then(
           (s) => s.isFile(),
           () => false
         );
         if (!isFile) {
           return `Refused: ${filePath} is not a file. Write the script first, then review the path you wrote.`;
         }
-        const relativeScriptPath = relative4(resolvedCwd.target, resolved2.target);
+        const relativeScriptPath = relative5(resolvedCwd.target, resolved2.target);
         if (!commandReferencesScript(
           command,
           resolved2.target,
@@ -3968,7 +4409,7 @@ function storeApproval(root) {
   return async (req) => {
     const store = useWizard.getState();
     if (store.isCommandApproved(req.command, req.cwd)) return "approve";
-    const rel = relative5(root, req.cwd);
+    const rel = relative6(root, req.cwd);
     const answer = await store.requestUserInput({
       prompt: "Run this command?",
       promptType: "commandApproval",
@@ -4194,8 +4635,8 @@ function defaultCreateModel() {
 }
 function approvedCommandHistory(approvedCommands) {
   return Array.from(approvedCommands).map((entry) => {
-    const sep3 = entry.indexOf("\0");
-    return { cwd: entry.slice(0, sep3), command: entry.slice(sep3 + 1) };
+    const sep4 = entry.indexOf("\0");
+    return { cwd: entry.slice(0, sep4), command: entry.slice(sep4 + 1) };
   });
 }
 async function classifyCommandSafety(createModel, command, cwd, explanation, approvedHistory) {
@@ -4312,14 +4753,14 @@ async function runReviewedCommand(ctx, command, cwd) {
   const approval = getReviewedCommandApproval(ctx, command, cwd);
   if (!approval) return void 0;
   if (!await reviewedCommandApprovalIsCurrent(approval)) {
-    return `Refused: ${relative5(ctx.root, approval.filePath)} changed after review. Call reviewScript again before running it.`;
+    return `Refused: ${relative6(ctx.root, approval.filePath)} changed after review. Call reviewScript again before running it.`;
   }
   const [env, secrets] = await Promise.all([
     resolveShellEnv(ctx, command),
     resolveSecretShellEnv(ctx, command)
   ]);
   if (!await reviewedCommandApprovalIsCurrent(approval)) {
-    return `Refused: ${relative5(ctx.root, approval.filePath)} changed after review. Call reviewScript again before running it.`;
+    return `Refused: ${relative6(ctx.root, approval.filePath)} changed after review. Call reviewScript again before running it.`;
   }
   const result = await runAndRecord(
     ctx,
@@ -4923,10 +5364,13 @@ var MODE_CONFIG = {
   ingestion: {
     instructions: [
       "Analyze the codebase to find the data entities (models) that should be ingested into Algolia.",
+      "Assume this is a new Algolia customer project. Existing Algolia dependencies, credentials, indices, and integration code are not required.",
+      "This workflow creates the Algolia integration, so its absence is expected and is not a failure.",
+      "Infer entity candidates from domain models, database schemas, data-access code, API handlers, and representative application data.",
       "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.",
       "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.",
+      "Use as few tools as possible, but do not guess. If no domain entities exist, report success with an empty array.",
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
       "When done, call reportStatus"
     ],
@@ -5389,16 +5833,16 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 // src/actions/implement.ts
 import z28 from "zod";
 import { access, mkdir as mkdir5, readFile as readFile9 } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join11, relative as relative6, resolve as resolve5, sep as sep2 } from "node:path";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join11, relative as relative7, resolve as resolve5, sep as sep3 } from "node:path";
 
 // src/lib/git.ts
-import { execFile as execFile2 } from "node:child_process";
-import { copyFile, mkdir as mkdir4, stat as stat3 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname3, isAbsolute as isAbsolute2, join as join9, resolve as resolve4 } from "node:path";
+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";
 var MAX_BUFFER = 32 * 1024 * 1024;
 function git(args) {
   return new Promise((resolve6, reject) => {
-    execFile2("git", args, { maxBuffer: MAX_BUFFER }, (err, stdout, stderr) => {
+    execFile3("git", args, { maxBuffer: MAX_BUFFER }, (err, stdout, stderr) => {
       if (err)
         return reject(
           new Error(
@@ -5423,9 +5867,9 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
   if (!trimmed) {
     return { ok: false, reason: "no file path was provided" };
   }
-  const source = isAbsolute2(trimmed) ? trimmed : resolve4(repoRoot, trimmed);
+  const source = isAbsolute3(trimmed) ? trimmed : resolve4(repoRoot, trimmed);
   try {
-    if (!(await stat3(source)).isFile()) {
+    if (!(await stat4(source)).isFile()) {
       return { ok: false, reason: `"${sourcePath}" is not a file` };
     }
   } catch {
@@ -5819,7 +6263,7 @@ function parseIngestRecordCount(output) {
   return Number.isFinite(count) ? count : void 0;
 }
 function relativeIngestCwd(execution, repoRoot) {
-  const cwd = relative6(repoRoot, execution.cwd);
+  const cwd = relative7(repoRoot, execution.cwd);
   return cwd && cwd !== "." ? cwd : ".";
 }
 function reportedCommandWithCwdNote(execution, repoRoot) {
@@ -5936,8 +6380,8 @@ async function frontendHasPackageJson(repoRoot, searchLocation) {
   let directory = repoRoot;
   if (searchLocation) {
     const candidate = dirname5(resolve5(repoRoot, searchLocation));
-    const candidateRelative = relative6(repoRoot, candidate);
-    const outsideRoot = candidateRelative === ".." || candidateRelative.startsWith(`..${sep2}`) || isAbsolute3(candidateRelative);
+    const candidateRelative = relative7(repoRoot, candidate);
+    const outsideRoot = candidateRelative === ".." || candidateRelative.startsWith(`..${sep3}`) || isAbsolute4(candidateRelative);
     if (!outsideRoot) directory = candidate;
   }
   for (; ; ) {
@@ -6169,7 +6613,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     if (agentRuns > 0) ctx.recordStepExecution();
     agentRuns += 1;
     const writtenFiles = [...new Set(useWizard.getState().writtenFiles)].map(
-      (file) => relative6(repoRoot, file)
+      (file) => relative7(repoRoot, file)
     );
     return runAgent({
       operation: "search-validation",
@@ -6309,7 +6753,7 @@ ${detail}` : ""}`
     const trackComponentGenerated = (mounted_successfully, attempts) => {
       const searchFilesChanged = [
         ...new Set(useWizard.getState().writtenFiles)
-      ].map((file) => relative6(repoRoot, file));
+      ].map((file) => relative7(repoRoot, file));
       track("AI Wizard Frontend Component Generated", {
         file_paths: searchFilesChanged,
         framework,
@@ -6344,7 +6788,7 @@ ${detail}` : ""}`
       buildCheckPlan ??= await resolveBuildCheckPlan(ctx, repoRoot, input);
       const searchFilesChanged = [
         ...new Set(useWizard.getState().writtenFiles)
-      ].map((file) => relative6(repoRoot, file));
+      ].map((file) => relative7(repoRoot, file));
       const validation = await runValidationUseCase(
         validationRunInstructions(buildCheckPlan, searchFilesChanged, attempt)
       );
@@ -8547,7 +8991,7 @@ async function resetProjectState() {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.81.0",
+  version: "0.83.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {

package/package.json

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