@buildautomaton/cli 0.1.94 → 0.1.96

package/dist/worker.js

@@ -773,7 +773,7 @@ function readMigrationSql(filename, ...searchSubdirs) {
     join(moduleDir, "..", sub, filename),
     join(moduleDir, "..", "..", "dist", sub, filename)
   ]);
-  const resolved = candidates.find((path16) => existsSync(path16));
+  const resolved = candidates.find((path14) => existsSync(path14));
   if (!resolved) {
     throw new Error(`Missing SQLite migration SQL: ${filename} (searched ${searchSubdirs.join(", ")})`);
   }
@@ -1124,31 +1124,18 @@ var init_constants = __esm({
   }
 });
 
-// ../bridge/src/prompt-turn-queue/paths.ts
-import path5 from "node:path";
-import os4 from "node:os";
-function getPromptQueuesDirectory() {
-  const override = process.env.BUILDAMATON_PROMPT_QUEUES_DIR?.trim();
-  if (override) return path5.resolve(override);
-  return path5.join(os4.homedir(), ".buildautomaton", "queues");
-}
-var init_paths = __esm({
-  "../bridge/src/prompt-turn-queue/paths.ts"() {
-  }
-});
-
 // ../bridge/src/sqlite/legacy_migration/archive-to-old-version.ts
 import fs7 from "node:fs";
-import path6 from "node:path";
+import path5 from "node:path";
 function moveLegacyFileToOldVersionBackup(category, sourcePath) {
-  const destDir = path6.join(OLD_VERSION_DIR, category);
+  const destDir = path5.join(OLD_VERSION_DIR, category);
   fs7.mkdirSync(destDir, { recursive: true });
-  const base = path6.basename(sourcePath);
-  let dest = path6.join(destDir, base);
+  const base = path5.basename(sourcePath);
+  let dest = path5.join(destDir, base);
   if (fs7.existsSync(dest)) {
-    const ext = path6.extname(base);
+    const ext = path5.extname(base);
     const stem = ext ? base.slice(0, -ext.length) : base;
-    dest = path6.join(destDir, `${stem}-${Date.now()}${ext}`);
+    dest = path5.join(destDir, `${stem}-${Date.now()}${ext}`);
   }
   fs7.renameSync(sourcePath, dest);
 }
@@ -1157,19 +1144,19 @@ var init_archive_to_old_version = __esm({
   "../bridge/src/sqlite/legacy_migration/archive-to-old-version.ts"() {
     "use strict";
     init_constants();
-    OLD_VERSION_DIR = path6.join(INDEX_DIR, "old-version");
+    OLD_VERSION_DIR = path5.join(INDEX_DIR, "old-version");
   }
 });
 
 // ../bridge/src/sqlite/legacy_migration/archive-file-index-json.ts
 import fs8 from "node:fs";
-import path7 from "node:path";
+import path6 from "node:path";
 function archiveLegacyFileIndexJsonFiles() {
   try {
     if (!fs8.existsSync(INDEX_DIR)) return;
     for (const name of fs8.readdirSync(INDEX_DIR)) {
       if (name.startsWith(".file-index-") && name.endsWith(".json")) {
-        const full = path7.join(INDEX_DIR, name);
+        const full = path6.join(INDEX_DIR, name);
         try {
           moveLegacyFileToOldVersionBackup("file-index", full);
         } catch (err) {
@@ -1191,15 +1178,15 @@ var init_archive_file_index_json = __esm({
 
 // ../bridge/src/sqlite/legacy_migration/import-agent-sessions-from-disk.ts
 import fs9 from "node:fs";
-import path8 from "node:path";
-import os5 from "node:os";
+import path7 from "node:path";
+import os4 from "node:os";
 function importLegacyAgentSessionsFromDisk(db) {
   try {
     if (!fs9.existsSync(LEGACY_AGENT_SESSION_DIR)) return;
     const names = fs9.readdirSync(LEGACY_AGENT_SESSION_DIR).filter((n) => n.endsWith(".json"));
     for (const name of names) {
       const sessionKey = name.slice(0, -".json".length);
-      const full = path8.join(LEGACY_AGENT_SESSION_DIR, name);
+      const full = path7.join(LEGACY_AGENT_SESSION_DIR, name);
       let raw;
       try {
         raw = fs9.readFileSync(full, "utf8");
@@ -1236,89 +1223,27 @@ var init_import_agent_sessions_from_disk = __esm({
   "../bridge/src/sqlite/legacy_migration/import-agent-sessions-from-disk.ts"() {
     "use strict";
     init_archive_to_old_version();
-    LEGACY_AGENT_SESSION_DIR = path8.join(os5.homedir(), ".buildautomaton", "agent-sessions");
-  }
-});
-
-// ../bridge/src/sqlite/legacy_migration/parse-persisted-queue-json.ts
-function parsePersistedQueueFromJson(raw) {
-  try {
-    const o = JSON.parse(raw);
-    const queueKey = typeof o.queueKey === "string" ? o.queueKey : typeof o.queueKeyHash === "string" ? o.queueKeyHash : null;
-    if (!queueKey || typeof o.updatedAt !== "string" || !Array.isArray(o.turns)) return null;
-    return { queueKey, updatedAt: o.updatedAt, turns: o.turns };
-  } catch {
-    return null;
-  }
-}
-var init_parse_persisted_queue_json = __esm({
-  "../bridge/src/sqlite/legacy_migration/parse-persisted-queue-json.ts"() {
-    "use strict";
-  }
-});
-
-// ../bridge/src/sqlite/legacy_migration/import-prompt-queues-from-disk.ts
-import fs10 from "node:fs";
-import path9 from "node:path";
-function importLegacyPromptQueuesFromDisk(db) {
-  try {
-    const dir = getPromptQueuesDirectory();
-    if (!fs10.existsSync(dir)) return;
-    for (const name of fs10.readdirSync(dir)) {
-      if (!name.endsWith(".json")) continue;
-      const full = path9.join(dir, name);
-      let raw;
-      try {
-        raw = fs10.readFileSync(full, "utf8");
-      } catch {
-        continue;
-      }
-      const file = parsePersistedQueueFromJson(raw);
-      if (!file) continue;
-      db.run(
-        `INSERT OR REPLACE INTO prompt_queue (queue_key, updated_at, turns_json) VALUES (?, ?, ?)`,
-        [file.queueKey, file.updatedAt, JSON.stringify(file.turns)]
-      );
-      try {
-        moveLegacyFileToOldVersionBackup("queues", full);
-      } catch {
-      }
-    }
-  } catch (e) {
-    console.error("[cli-sqlite] legacy import: prompt queues from disk failed", e);
-  }
-}
-var init_import_prompt_queues_from_disk = __esm({
-  "../bridge/src/sqlite/legacy_migration/import-prompt-queues-from-disk.ts"() {
-    "use strict";
-    init_paths();
-    init_archive_to_old_version();
-    init_parse_persisted_queue_json();
+    LEGACY_AGENT_SESSION_DIR = path7.join(os4.homedir(), ".buildautomaton", "agent-sessions");
   }
 });
 
 // ../bridge/src/sqlite/legacy_migration/import-cli-legacy-disk-data.ts
-import fs11 from "node:fs";
+import fs10 from "node:fs";
 function legacyCliDiskMigrationIsPending() {
   try {
-    if (fs11.existsSync(INDEX_DIR)) {
-      for (const name of fs11.readdirSync(INDEX_DIR)) {
+    if (fs10.existsSync(INDEX_DIR)) {
+      for (const name of fs10.readdirSync(INDEX_DIR)) {
         if (name.startsWith(".file-index-") && name.endsWith(".json")) return true;
       }
     }
   } catch {
   }
   try {
-    if (fs11.existsSync(LEGACY_AGENT_SESSION_DIR)) {
-      if (fs11.readdirSync(LEGACY_AGENT_SESSION_DIR).some((n) => n.endsWith(".json"))) return true;
+    if (fs10.existsSync(LEGACY_AGENT_SESSION_DIR)) {
+      if (fs10.readdirSync(LEGACY_AGENT_SESSION_DIR).some((n) => n.endsWith(".json"))) return true;
     }
   } catch {
   }
-  try {
-    const dir = getPromptQueuesDirectory();
-    if (fs11.existsSync(dir) && fs11.readdirSync(dir).some((n) => n.endsWith(".json"))) return true;
-  } catch {
-  }
   return false;
 }
 function importCliSqliteLegacyDiskData(db, log) {
@@ -1328,7 +1253,6 @@ function importCliSqliteLegacyDiskData(db, log) {
   }
   archiveLegacyFileIndexJsonFiles();
   importLegacyAgentSessionsFromDisk(db);
-  importLegacyPromptQueuesFromDisk(db);
   if (pending && log) {
     log("Legacy on-disk CLI data migration finished.");
   }
@@ -1337,10 +1261,8 @@ var init_import_cli_legacy_disk_data = __esm({
   "../bridge/src/sqlite/legacy_migration/import-cli-legacy-disk-data.ts"() {
     "use strict";
     init_constants();
-    init_paths();
     init_archive_file_index_json();
     init_import_agent_sessions_from_disk();
-    init_import_prompt_queues_from_disk();
   }
 });
 
@@ -1769,7 +1691,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path16, checkUnignored, mode) {
+      test(path14, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -1778,7 +1700,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path16);
+          const matched = rule[mode].test(path14);
           if (!matched) {
             return;
           }
@@ -1799,17 +1721,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path16, originalPath, doThrow) => {
-      if (!isString(path16)) {
+    var checkPath = (path14, originalPath, doThrow) => {
+      if (!isString(path14)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path16) {
+      if (!path14) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path16)) {
+      if (checkPath.isNotRelative(path14)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -1818,7 +1740,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path16) => REGEX_TEST_INVALID_PATH.test(path16);
+    var isNotRelative = (path14) => REGEX_TEST_INVALID_PATH.test(path14);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -1848,19 +1770,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path16 = originalPath && checkPath.convert(originalPath);
+        const path14 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path16,
+          path14,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path16, cache, checkUnignored, slices);
+        return this._t(path14, cache, checkUnignored, slices);
       }
-      checkIgnore(path16) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path16)) {
-          return this.test(path16);
+      checkIgnore(path14) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path14)) {
+          return this.test(path14);
         }
-        const slices = path16.split(SLASH).filter(Boolean);
+        const slices = path14.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -1873,18 +1795,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path16, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path14, false, MODE_CHECK_IGNORE);
       }
-      _t(path16, cache, checkUnignored, slices) {
-        if (path16 in cache) {
-          return cache[path16];
+      _t(path14, cache, checkUnignored, slices) {
+        if (path14 in cache) {
+          return cache[path14];
         }
         if (!slices) {
-          slices = path16.split(SLASH).filter(Boolean);
+          slices = path14.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path16] = this._rules.test(path16, checkUnignored, MODE_IGNORE);
+          return cache[path14] = this._rules.test(path14, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -1892,29 +1814,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path16] = parent.ignored ? parent : this._rules.test(path16, checkUnignored, MODE_IGNORE);
+        return cache[path14] = parent.ignored ? parent : this._rules.test(path14, checkUnignored, MODE_IGNORE);
       }
-      ignores(path16) {
-        return this._test(path16, this._ignoreCache, false).ignored;
+      ignores(path14) {
+        return this._test(path14, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path16) => !this.ignores(path16);
+        return (path14) => !this.ignores(path14);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path16) {
-        return this._test(path16, this._testCache, true);
+      test(path14) {
+        return this._test(path14, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path16) => checkPath(path16 && checkPath.convert(path16), path16, RETURN_FALSE);
+    var isPathValid = (path14) => checkPath(path14 && checkPath.convert(path14), path14, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path16) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path16) || isNotRelative(path16);
+      checkPath.isNotRelative = (path14) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path14) || isNotRelative(path14);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -1930,8 +1852,8 @@ var require_ignore = __commonJS({
 });
 
 // ../bridge/src/code-nav/gitignore-filter.ts
-import fs12 from "node:fs";
-import path10 from "node:path";
+import fs11 from "node:fs";
+import path8 from "node:path";
 function normalizeRelPath(relPath) {
   return relPath.replace(/\\/g, "/");
 }
@@ -1941,12 +1863,12 @@ function isUnderDir(relPath, dirRel) {
 async function createGitignoreFilterForRelativePath(root, relPath) {
   const filter = new GitignoreFilter();
   await filter.enterDirectory(root, "");
-  const dirRel = normalizeRelPath(path10.dirname(relPath));
+  const dirRel = normalizeRelPath(path8.dirname(relPath));
   if (dirRel === "." || dirRel === "") return filter;
   let abs = root;
   let rel = "";
   for (const segment of dirRel.split("/")) {
-    abs = path10.join(abs, segment);
+    abs = path8.join(abs, segment);
     rel = rel ? `${rel}/${segment}` : segment;
     await filter.enterDirectory(abs, rel);
   }
@@ -1968,7 +1890,7 @@ var init_gitignore_filter = __esm({
       /** Load `.gitignore` in `absDir` and push a layer when the file exists. */
       async enterDirectory(absDir, dirRel) {
         try {
-          const content = await fs12.promises.readFile(path10.join(absDir, ".gitignore"), "utf8");
+          const content = await fs11.promises.readFile(path8.join(absDir, ".gitignore"), "utf8");
           this.layers.push({ dirRel, ig: (0, import_ignore.default)().add(content) });
         } catch {
         }
@@ -1995,7 +1917,7 @@ var init_gitignore_filter = __esm({
 });
 
 // ../bridge/src/code-nav/language-registry.ts
-import path11 from "node:path";
+import path9 from "node:path";
 function languageAssetPaths(key, wasmFile) {
   return {
     wasmFile,
@@ -2003,7 +1925,7 @@ function languageAssetPaths(key, wasmFile) {
   };
 }
 function getLanguageKeyForFilePath(filePath) {
-  const ext = path11.extname(filePath).replace(/^\./, "").toLowerCase();
+  const ext = path9.extname(filePath).replace(/^\./, "").toLowerCase();
   if (!ext) return null;
   return EXT_TO_LANGUAGE_KEY[ext] ?? null;
 }
@@ -2053,13 +1975,13 @@ var init_language_registry = __esm({
 });
 
 // ../bridge/src/code-nav/walk-code-nav-files.ts
-import fs13 from "node:fs";
-import path12 from "node:path";
+import fs12 from "node:fs";
+import path10 from "node:path";
 async function walkCodeNavFilesInDirectory(dir, baseDir, relDir, filter, onFile, state) {
   await filter.enterDirectory(dir, relDir);
   let names;
   try {
-    names = await fs13.promises.readdir(dir);
+    names = await fs12.promises.readdir(dir);
   } catch {
     filter.leaveDirectory(relDir);
     return;
@@ -2076,10 +1998,10 @@ async function walkCodeNavFilesInDirectory(dir, baseDir, relDir, filter, onFile,
     }
     state.n++;
     const relPath = relDir ? `${relDir}/${name}` : name;
-    const full = path12.join(dir, name);
+    const full = path10.join(dir, name);
     let stat;
     try {
-      stat = await fs13.promises.stat(full);
+      stat = await fs12.promises.stat(full);
     } catch {
       continue;
     }
@@ -2096,7 +2018,7 @@ async function walkCodeNavFilesInDirectory(dir, baseDir, relDir, filter, onFile,
   filter.leaveDirectory(relDir);
 }
 async function walkCodeNavFilesAsync(rootDir, onFile, state = createWalkYieldState()) {
-  const resolved = path12.resolve(rootDir);
+  const resolved = path10.resolve(rootDir);
   const filter = new GitignoreFilter();
   await walkCodeNavFilesInDirectory(resolved, resolved, "", filter, onFile, state);
 }
@@ -2138,12 +2060,12 @@ var init_bridge_root = __esm({
 });
 
 // ../bridge/src/files/index/paths.ts
-import path13 from "node:path";
+import path11 from "node:path";
 import crypto from "node:crypto";
 function getCwdHashForFileIndex(resolvedCwd) {
-  return crypto.createHash("sha256").update(path13.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
+  return crypto.createHash("sha256").update(path11.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
 }
-var init_paths2 = __esm({
+var init_paths = __esm({
   "../bridge/src/files/index/paths.ts"() {
     init_constants();
   }
@@ -2204,7 +2126,7 @@ var init_parent_path = __esm({
   "../bridge/src/code-nav/symbol-index/sqlite/parent-path.ts"() {
     "use strict";
     init_bridge_root();
-    init_paths2();
+    init_paths();
     init_normalize_resolved_path();
     init_database();
     init_symbol_index_version();
@@ -2832,7 +2754,7 @@ var init_persist_single_file = __esm({
 });
 
 // ../bridge/src/code-nav/resolve-module-import-path.ts
-import path14 from "node:path";
+import path12 from "node:path";
 function normalizeWorkspacePath(filePath) {
   return filePath.replace(/\\/g, "/").replace(/^\/+/, "");
 }
@@ -2872,28 +2794,28 @@ function tsJsImportCandidates(joined) {
 function resolveModuleImportPath(importerFilePath, moduleSpecifier, workspaceFiles) {
   const spec = moduleSpecifier.trim();
   if (!spec || !isRelativeModuleSpecifier(spec)) return null;
-  const importerDir = path14.posix.dirname(normalizeWorkspacePath(importerFilePath));
-  const joined = normalizeWorkspacePath(path14.posix.normalize(path14.posix.join(importerDir, spec)));
+  const importerDir = path12.posix.dirname(normalizeWorkspacePath(importerFilePath));
+  const joined = normalizeWorkspacePath(path12.posix.normalize(path12.posix.join(importerDir, spec)));
   return firstExistingPath(tsJsImportCandidates(joined), workspaceFiles);
 }
 function resolvePythonModulePath(importerFilePath, moduleSpecifier, workspaceFiles) {
   const moduleName = moduleSpecifier.trim().replace(/\s+/g, "");
   if (!moduleName) return null;
-  const importerDir = path14.posix.dirname(normalizeWorkspacePath(importerFilePath));
+  const importerDir = path12.posix.dirname(normalizeWorkspacePath(importerFilePath));
   if (moduleName.startsWith(".")) {
     const dotMatch = /^(\.+)(.*)$/.exec(moduleName);
     const dotCount = dotMatch?.[1]?.length ?? 1;
     const rest = (dotMatch?.[2] ?? "").replace(/^\./, "");
     let baseDir = importerDir;
     for (let i = 1; i < dotCount; i++) {
-      baseDir = path14.posix.dirname(baseDir);
+      baseDir = path12.posix.dirname(baseDir);
     }
     const dottedPath2 = rest ? rest.split(".").join("/") : "";
-    const relativeBase = dottedPath2 ? path14.posix.join(baseDir, dottedPath2) : baseDir;
+    const relativeBase = dottedPath2 ? path12.posix.join(baseDir, dottedPath2) : baseDir;
     return firstExistingPath(
       [
         ...withSuffixes(relativeBase, PYTHON_EXTENSIONS),
-        ...withSuffixes(path14.posix.join(relativeBase, "__init__"), [".py"])
+        ...withSuffixes(path12.posix.join(relativeBase, "__init__"), [".py"])
       ],
       workspaceFiles
     );
@@ -2902,7 +2824,7 @@ function resolvePythonModulePath(importerFilePath, moduleSpecifier, workspaceFil
   return firstExistingPath(
     [
       ...withSuffixes(dottedPath, PYTHON_EXTENSIONS),
-      ...withSuffixes(path14.posix.join(importerDir, dottedPath), PYTHON_EXTENSIONS)
+      ...withSuffixes(path12.posix.join(importerDir, dottedPath), PYTHON_EXTENSIONS)
     ],
     workspaceFiles
   );
@@ -2910,9 +2832,9 @@ function resolvePythonModulePath(importerFilePath, moduleSpecifier, workspaceFil
 function resolveIncludePath(importerFilePath, includePath, workspaceFiles) {
   const spec = includePath.trim().replace(/^["']|["']$/g, "");
   if (!spec) return null;
-  const importerDir = path14.posix.dirname(normalizeWorkspacePath(importerFilePath));
+  const importerDir = path12.posix.dirname(normalizeWorkspacePath(importerFilePath));
   const joined = normalizeWorkspacePath(
-    path14.posix.normalize(path14.posix.join(importerDir, spec.replace(/\\/g, "/")))
+    path12.posix.normalize(path12.posix.join(importerDir, spec.replace(/\\/g, "/")))
   );
   if (workspaceFiles.has(joined)) return joined;
   return firstExistingPath(withSuffixes(joined, C_CPP_EXTENSIONS), workspaceFiles);
@@ -2931,8 +2853,8 @@ function resolveGoImportPath(importerFilePath, moduleSpecifier, workspaceFiles)
   const spec = moduleSpecifier.trim();
   if (!spec) return null;
   if (isRelativeModuleSpecifier(spec)) {
-    const importerDir = path14.posix.dirname(normalizeWorkspacePath(importerFilePath));
-    const joined = normalizeWorkspacePath(path14.posix.normalize(path14.posix.join(importerDir, spec)));
+    const importerDir = path12.posix.dirname(normalizeWorkspacePath(importerFilePath));
+    const joined = normalizeWorkspacePath(path12.posix.normalize(path12.posix.join(importerDir, spec)));
     if (workspaceFiles.has(joined)) return joined;
     return firstExistingPath(withSuffixes(joined, [".go"]), workspaceFiles);
   }
@@ -4339,12 +4261,12 @@ var init_workspace_files = __esm({
 });
 
 // ../bridge/src/code-nav/symbol-index/build/extract-file-symbol-data.ts
-import fs14 from "node:fs";
-import path15 from "node:path";
+import fs13 from "node:fs";
+import path13 from "node:path";
 import { isMainThread as isMainThread3 } from "node:worker_threads";
 async function extractFileSymbolData(resolved, relPath, workspaceFilesOverride) {
   await yieldForBridgeInteractivePriority();
-  const absPath = path15.join(resolved, relPath);
+  const absPath = path13.join(resolved, relPath);
   let tags = [];
   let source = null;
   if (isCodeNavSupportedPath(relPath) && !await isPathGitIgnored(resolved, relPath)) {
@@ -4352,16 +4274,16 @@ async function extractFileSymbolData(resolved, relPath, workspaceFilesOverride)
       assertBackgroundIndexingAllowed();
       let fileSource = null;
       if (isMainThread3) {
-        const stat = await fs14.promises.stat(absPath);
+        const stat = await fs13.promises.stat(absPath);
         if (stat.isFile() && stat.size <= MAX_INDEX_FILE_BYTES) {
           assertBackgroundIndexingAllowed();
-          fileSource = await fs14.promises.readFile(absPath, "utf8");
+          fileSource = await fs13.promises.readFile(absPath, "utf8");
         }
       } else {
-        const stat = fs14.statSync(absPath);
+        const stat = fs13.statSync(absPath);
         if (stat.isFile() && stat.size <= MAX_INDEX_FILE_BYTES) {
           assertBackgroundIndexingAllowed();
-          fileSource = fs14.readFileSync(absPath, "utf8");
+          fileSource = fs13.readFileSync(absPath, "utf8");
         }
       }
       source = fileSource;