token-goat 2.9.18 → 2.9.20

package/dist/{token-goat-chunk-V3ZWBEHM.mjs → token-goat-chunk-I5PQRHFE.mjs}

@@ -1,34 +1,39 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
-  enqueueDirtyPathSafe,
+  enqueueDirtyPathsSafe,
+  fenceUntrusted,
   getToolName,
-  getTrackedFiles
-} from "./token-goat-chunk-BFEWOMA3.mjs";
+  getTrackedFiles,
+  scanAndRecord
+} from "./token-goat-chunk-DPHJU3P7.mjs";
 import {
-  indexRecallEntry
-} from "./token-goat-chunk-CTOYJ232.mjs";
+  RECALL_DEFAULT_LIMIT,
+  indexRecallEntry,
+  listRecentRecall,
+  searchRecall
+} from "./token-goat-chunk-SL454EN5.mjs";
 import {
   isBlobStale,
   loadBlob,
   redactSecrets,
   storeBlob
-} from "./token-goat-chunk-HPOFR6QX.mjs";
+} from "./token-goat-chunk-K5XPIUVB.mjs";
 import {
-  PARSER_FINGERPRINT
-} from "./token-goat-chunk-W3E65QOW.mjs";
+  parserFingerprintForLanguage
+} from "./token-goat-chunk-ERGHDBC6.mjs";
 import {
   getProjectFileEntries,
   projectScopeClause
-} from "./token-goat-chunk-I67CPTDD.mjs";
+} from "./token-goat-chunk-K3ZNBN4U.mjs";
 import {
   getDb
-} from "./token-goat-chunk-L7VCX33I.mjs";
+} from "./token-goat-chunk-T63VHOL3.mjs";
 import {
   fingerprintFile,
   getDisplayRoot,
   shortFingerprint
-} from "./token-goat-chunk-CA6V36KW.mjs";
+} from "./token-goat-chunk-74ADIZZX.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-EEIDFMEM.mjs";
@@ -37,14 +42,18 @@ import {
   countNoun,
   extractErrorMessage,
   foldPath,
-  globalDbPath
-} from "./token-goat-chunk-QIDLJGXZ.mjs";
+  globalDbPath,
+  pad
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
 import {
+  UNTRUSTED_TOOL_TAG,
+  UNTRUSTED_WEB_TAG,
   displaySafeJson,
+  fenceUntrustedContent,
   normalizePath,
   resolveIndexPath,
   toDisplayPath
-} from "./token-goat-chunk-ERTXEKB6.mjs";
+} from "./token-goat-chunk-NMTKNYGF.mjs";
 import {
   compileGuardedRegex
 } from "./token-goat-chunk-GMOUBOX4.mjs";
@@ -525,7 +534,7 @@ async function describeTarget(target, table, opts) {
   const absPath = resolve(process.cwd(), target);
   if (existsSync(absPath)) {
     try {
-      const { isSqliteFile, getSqliteSchema, formatSqliteSchema } = await import("./token-goat-chunk-4EXFN2AW.mjs");
+      const { isSqliteFile, getSqliteSchema, formatSqliteSchema } = await import("./token-goat-chunk-OZRSREKR.mjs");
       if (isSqliteFile(absPath)) {
         const schema = getSqliteSchema(absPath);
         if (table) {
@@ -752,6 +761,10 @@ function checkSymbolBodySize(dbPath) {
   }
 }
 
+// src/mcp_tool_pattern.ts
+init_define_import_meta_env();
+var MCP_TOOL_PATTERN = "^mcp__";
+
 // src/reconcile.ts
 init_define_import_meta_env();
 import * as fs2 from "node:fs";
@@ -821,7 +834,7 @@ function runReconcile(opts = {}) {
     lines.push(`${countNoun(result.embedStale, "file")} of the above ${result.embedStale === 1 ? "was" : "were"} unchanged on disk but held out-of-date embeddings (${reembedVerb}).`);
   }
   if (result.trackedUnavailable) {
-    lines.push("This project has an index but git listed no files in it, so nothing could be compared and no deletions were computed. Run token-goat inside the repository, or reindex with --walk if this directory is deliberately not under git.");
+    lines.push("This project has an index but git listed no files in it, so nothing on disk was compared against it and changed or new files could not be found. Files gone from disk were still detected. Run token-goat inside the repository, or reindex with --walk if this directory is deliberately not under git.");
   }
   if (result.budgetExhausted) {
     lines.push(`Stopped at the ${result.elapsedMs}ms budget with ${countNoun(result.unscanned, "file")} unchecked, so there may be more drift; deletions were not computed at all, because an unchecked file is indistinguishable from a deleted one. Raise --budget-ms for a complete sweep.`);
@@ -877,7 +890,7 @@ function reconcileProject(opts = {}) {
       added.push(file);
       continue;
     }
-    if (entry.parserSha !== PARSER_FINGERPRINT) {
+    if (entry.parserSha !== parserFingerprintForLanguage(entry.language)) {
       changed.push(file);
       parserStale++;
       continue;
@@ -908,7 +921,7 @@ function reconcileProject(opts = {}) {
   }
   const trackedUnavailable = tracked.length === 0 && indexed.size > 0;
   const removed = [];
-  if (!budgetExhausted && !trackedUnavailable) {
+  if (!budgetExhausted) {
     for (const [folded, entry] of indexed) {
       if (seenOnDisk.has(folded)) continue;
       if (Date.now() - startedAt > budgetMs) {
@@ -918,17 +931,17 @@ function reconcileProject(opts = {}) {
       }
       try {
         fs2.statSync(entry.filePath);
-      } catch {
-        removed.push(entry.filePath);
+      } catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT" || code === "ENOTDIR") removed.push(entry.filePath);
       }
     }
   }
   let enqueued = 0;
   if (opts.dryRun !== true) {
-    for (const p of [...changed, ...added, ...removed]) {
-      enqueueDirtyPathSafe(resolveIndexPath(p, cwd), { alreadyResolved: true });
-      enqueued++;
-    }
+    const toEnqueue = [...changed, ...added, ...removed].map((p) => resolveIndexPath(p, cwd));
+    enqueueDirtyPathsSafe(toEnqueue, { alreadyResolved: true });
+    enqueued = toEnqueue.length;
     if (budgetExhausted) {
       if (lastScanned !== null) writeReconcileCursor(dbPath, projectRoot, lastScanned);
     } else if (tracked.length > 0) {
@@ -951,8 +964,72 @@ function reconcileProject(opts = {}) {
   };
 }
 
+// src/cli_recall.ts
+init_define_import_meta_env();
+var RECALL_COMMAND = {
+  bash: "bash-output",
+  web: "web-output",
+  mcp: "mcp-output"
+};
+function fenceTagForCacheType(cacheType) {
+  return cacheType === "web" ? UNTRUSTED_WEB_TAG : UNTRUSTED_TOOL_TAG;
+}
+function fenceRecallListing(text, hits) {
+  const tags = new Set(hits.map((hit) => fenceTagForCacheType(hit.cacheType)));
+  const tag = tags.size === 1 ? [...tags][0] ?? UNTRUSTED_TOOL_TAG : UNTRUSTED_TOOL_TAG;
+  return fenceUntrusted(text, tag);
+}
+function fenceSnippetIfMatched(hit) {
+  const matches = scanAndRecord(hit.snippet);
+  if (matches.length === 0) return hit.snippet;
+  return fenceUntrustedContent(hit.snippet, matches, fenceTagForCacheType(hit.cacheType));
+}
+function printHits(query, hits) {
+  const w = (text) => {
+    process.stdout.write(text);
+  };
+  if (hits.length === 0) {
+    w(query === void 0 ? "No cache entries yet.\n" : `No cache entries match: ${query}
+`);
+    return;
+  }
+  const body = hits.map((hit) => {
+    const label = hit.label.length > 80 ? hit.label.slice(0, 77) + "..." : hit.label;
+    const pointer = hit.blobPresent ? `  (token-goat ${RECALL_COMMAND[hit.cacheType]} ${hit.id})` : "  (blob expired -- content below is all that remains)";
+    return `[${pad(hit.cacheType, 4)}] ${hit.id}
+${pointer}
+  ${label}
+  ${hit.snippet}
+`;
+  }).join("\n");
+  w(`${fenceRecallListing(body, hits)}
+`);
+}
+function runRecallCommand(query, opts = {}) {
+  const browse = query === void 0 || query.trim() === "";
+  const scope = {
+    ...opts.type !== void 0 ? { type: opts.type } : {},
+    ...opts.limit !== void 0 ? { limit: opts.limit } : {}
+  };
+  const effectiveLimit = opts.limit ?? RECALL_DEFAULT_LIMIT;
+  const fetched = browse ? listRecentRecall({ ...scope, limit: effectiveLimit + 1 }) : searchRecall(query, { ...scope, limit: effectiveLimit + 1 });
+  const hits = fetched.slice(0, effectiveLimit);
+  if (fetched.length > hits.length) {
+    process.stderr.write(`Showing ${hits.length} entries; more are available (raise --limit to see them).
+`);
+  }
+  if (opts.json === true) {
+    const fenced = hits.map((hit) => ({ ...hit, snippet: fenceSnippetIfMatched(hit) }));
+    process.stdout.write(`${displaySafeJson(fenced, 0)}
+`);
+    return;
+  }
+  printHits(browse ? void 0 : query, hits);
+}
+
 export {
   checkSymbolBodySize,
+  MCP_TOOL_PATTERN,
   WEB_OUTPUT_SUBDIR,
   storeWebOutput,
   getWebOutput,
@@ -962,6 +1039,8 @@ export {
   runReconcile,
   isReconcileClean,
   reconcileProject,
+  RECALL_COMMAND,
+  runRecallCommand,
   MAX_STDIN_BYTES,
   readStdinJson,
   diagnoseSqlFailure,

package/dist/token-goat-chunk-ITWYDOKP.mjs

@@ -0,0 +1,341 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  ToolFilter,
+  compressedTokensSaved,
+  deliverCompressed,
+  dispatchArgv,
+  filterByName,
+  selectFilter
+} from "./token-goat-chunk-PAVWB4L4.mjs";
+import {
+  capTokens,
+  shlexSplit,
+  storeBashOutputSync
+} from "./token-goat-chunk-SL454EN5.mjs";
+import {
+  recordStat
+} from "./token-goat-chunk-K5XPIUVB.mjs";
+import {
+  detectHarness,
+  loadConfig
+} from "./token-goat-chunk-74ADIZZX.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/bash_runner.ts
+init_define_import_meta_env();
+import { spawn, spawnSync } from "node:child_process";
+import * as os from "node:os";
+
+// src/delivery_cap.ts
+init_define_import_meta_env();
+var CLAUDE_CODE_BASH_OUTPUT_CAP_BYTES = 2e4;
+var CLAUDE_CODE_PERSISTED_PREVIEW_BYTES = 2048;
+function bashOutputCapBytes(harness = detectHarness()) {
+  return harness === "claudecode" ? CLAUDE_CODE_BASH_OUTPUT_CAP_BYTES : null;
+}
+function clipToDeliveryCap(text, reserveBytes) {
+  const cap = bashOutputCapBytes();
+  const room = cap === null ? null : cap - reserveBytes;
+  if (room === null || room <= 0 || Buffer.byteLength(text, "utf-8") <= room) return { text, clipped: false };
+  const sliced = Buffer.from(text, "utf-8").subarray(0, room).toString("utf-8");
+  const lastNewline = sliced.lastIndexOf("\n");
+  return { text: lastNewline > 0 ? sliced.slice(0, lastNewline) : sliced, clipped: true };
+}
+function deliveredOutputBytes(originalBytes, harness) {
+  const cap = bashOutputCapBytes(harness);
+  if (cap === null) return Math.max(0, originalBytes);
+  if (originalBytes <= cap) return Math.max(0, originalBytes);
+  return CLAUDE_CODE_PERSISTED_PREVIEW_BYTES;
+}
+
+// src/shell.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var WSL_LAUNCHER_SEGMENTS = /* @__PURE__ */ new Set(["system32", "syswow64", "windowsapps"]);
+function isExecutable(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isWslLauncherDir(dir) {
+  return dir.toLowerCase().split(/[\\/]+/).some((seg) => WSL_LAUNCHER_SEGMENTS.has(seg));
+}
+function locateBashOnPath(pathValue, isExe = isExecutable) {
+  for (const dir of (pathValue ?? "").split(path.delimiter)) {
+    if (!dir || isWslLauncherDir(dir)) continue;
+    const cand = path.join(dir, "bash.exe");
+    if (isExe(cand)) return cand;
+  }
+  return null;
+}
+function knownGitBashPaths() {
+  const localPrograms = process.env["LOCALAPPDATA"] ? path.join(process.env["LOCALAPPDATA"], "Programs") : void 0;
+  const bases = [
+    process.env["ProgramFiles"],
+    process.env["ProgramFiles(x86)"],
+    process.env["ProgramW6432"],
+    localPrograms
+  ];
+  const out = [];
+  for (const base of bases) {
+    if (!base) continue;
+    out.push(path.join(base, "Git", "bin", "bash.exe"));
+    out.push(path.join(base, "Git", "usr", "bin", "bash.exe"));
+  }
+  return out;
+}
+function resolveWindowsBash() {
+  if (process.platform !== "win32") return null;
+  const override = process.env["TOKEN_GOAT_BASH"];
+  if (override && isExecutable(override)) return override;
+  const onPath = locateBashOnPath(process.env["PATH"]);
+  if (onPath) return onPath;
+  for (const cand of knownGitBashPaths()) {
+    if (isExecutable(cand)) return cand;
+  }
+  return null;
+}
+function wrappedShell() {
+  if (process.platform !== "win32") return true;
+  return resolveWindowsBash() ?? true;
+}
+function canRunWrappedShell() {
+  return process.platform !== "win32" || resolveWindowsBash() !== null;
+}
+
+// src/bash_runner.ts
+var IdentityFilter = class extends ToolFilter {
+  name = "passthrough";
+};
+var DEFAULT_TIMEOUT_SECONDS = 600;
+var MAX_CAPTURE_BYTES = 32 * 1024 * 1024;
+var MIN_RECORD_STAT_BYTES = 32;
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 15e3;
+var CaptureSink = class {
+  constructor(cap) {
+    this.cap = cap;
+  }
+  cap;
+  chunks = [];
+  bytes = 0;
+  overflowed = false;
+  push(chunk) {
+    if (this.overflowed) return;
+    this.bytes += chunk.length;
+    if (this.bytes > this.cap) {
+      this.overflowed = true;
+      return;
+    }
+    this.chunks.push(chunk);
+  }
+  text() {
+    return decode(Buffer.concat(this.chunks));
+  }
+};
+function scheduleHeartbeat(startTime, intervalMs, write) {
+  let interval = intervalMs;
+  let timer;
+  const arm = () => {
+    timer = setTimeout(() => {
+      write(Math.round((Date.now() - startTime) / 1e3));
+      interval *= 2;
+      arm();
+    }, interval);
+    timer.unref();
+  };
+  arm();
+  return {
+    onOutput: () => {
+      interval = intervalMs;
+      if (timer !== void 0) clearTimeout(timer);
+      arm();
+    },
+    stop: () => {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  };
+}
+function resolveFilter(command, filterName, cwd) {
+  const effectiveCwd = cwd ?? process.cwd();
+  let split;
+  try {
+    split = shlexSplit(command);
+  } catch {
+    split = null;
+  }
+  const argv = split === null ? [command] : dispatchArgv(split, effectiveCwd).argv;
+  if (filterName) {
+    const named = filterByName(filterName);
+    if (named !== null) return { filter: named, argv };
+  }
+  if (split === null) return { filter: null, argv };
+  return { filter: selectFilter(split, effectiveCwd), argv };
+}
+function baseSpawnOptions(timeout, cwd) {
+  return { timeout: timeout * 1e3, cwd };
+}
+function spawnTarget(command, nativeShell) {
+  const shell = nativeShell ? true : wrappedShell();
+  if (typeof shell === "string") return { file: shell, args: ["-c", 'eval "$TG_CMD"'], shell: false, cmdEnv: { TG_CMD: command } };
+  return { file: command, args: [], shell };
+}
+function mergeSpawnEnv(env, cmdEnv) {
+  return cmdEnv ? { ...env ?? process.env, ...cmdEnv } : env;
+}
+function signalExitCode(signal) {
+  const num = os.constants.signals[signal];
+  return 128 + (num ?? 0);
+}
+function resolveProfile(explicit) {
+  if (explicit) return explicit;
+  try {
+    const p = loadConfig().compression.profile;
+    return p && p !== "auto" ? p : "balanced";
+  } catch {
+    return "balanced";
+  }
+}
+function resolveCompressLimits() {
+  try {
+    const bc = loadConfig().bash_compress;
+    return { maxLines: bc.max_lines, maxBytes: bc.max_bytes };
+  } catch {
+    return { maxLines: 1e3, maxBytes: 64 * 1024 };
+  }
+}
+async function run(command, opts = {}) {
+  const timeout = opts.timeout ?? DEFAULT_TIMEOUT_SECONDS;
+  const { filter, argv } = resolveFilter(command, opts.filterName, opts.cwd);
+  if (filter === null) {
+    if ((opts.maxTokens ?? 0) > 0 || opts.quietSuccess) {
+      return wrapAndCompress(command, argv, new IdentityFilter(), timeout, resolveProfile(opts.compressionProfile), opts);
+    }
+    return passthrough(command, timeout, opts.cwd, opts.env, opts.nativeShell);
+  }
+  return wrapAndCompress(command, argv, filter, timeout, resolveProfile(opts.compressionProfile), opts);
+}
+function runRaw(command, timeout = DEFAULT_TIMEOUT_SECONDS) {
+  return passthrough(command, timeout, void 0, void 0);
+}
+function passthrough(command, timeout, cwd, env, nativeShell) {
+  const { file, args, shell, cmdEnv } = spawnTarget(command, nativeShell);
+  const result = spawnSync(file, args, {
+    ...baseSpawnOptions(timeout, cwd),
+    shell,
+    env: mergeSpawnEnv(env, cmdEnv),
+    stdio: "inherit"
+  });
+  if (isTimeout(result.error)) return 124;
+  if (result.status !== null) return result.status;
+  if (result.signal) return signalExitCode(result.signal);
+  return 0;
+}
+function isTimeout(error) {
+  return !!error && error.code === "ETIMEDOUT";
+}
+function decode(buf) {
+  if (buf == null) return "";
+  return typeof buf === "string" ? buf : buf.toString("utf8");
+}
+async function wrapAndCompress(command, argv, filter, timeout, profile, opts) {
+  const writeStdout = opts.writeStdout ?? ((s) => process.stdout.write(s));
+  const writeStderr = opts.writeStderr ?? ((s) => process.stderr.write(s));
+  const startTime = Date.now();
+  const { file, args, shell, cmdEnv } = spawnTarget(command, opts.nativeShell);
+  const stdoutSink = new CaptureSink(MAX_CAPTURE_BYTES);
+  const stderrSink = new CaptureSink(MAX_CAPTURE_BYTES);
+  let timedOut = false;
+  let overflowed = false;
+  const child = spawn(file, args, { cwd: opts.cwd, shell, env: mergeSpawnEnv(opts.env, cmdEnv), stdio: ["ignore", "pipe", "pipe"] });
+  const heartbeat = scheduleHeartbeat(startTime, opts.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS, (elapsed) => {
+    writeStderr(`[token-goat compress] still running, ${elapsed}s elapsed
+`);
+  });
+  const timeoutHandle = setTimeout(() => {
+    timedOut = true;
+    child.kill();
+  }, timeout * 1e3);
+  const onData = (sink) => (chunk) => {
+    heartbeat.onOutput();
+    sink.push(chunk);
+    if (sink.overflowed) {
+      overflowed = true;
+      child.kill();
+    }
+  };
+  child.stdout?.on("data", onData(stdoutSink));
+  child.stderr?.on("data", onData(stderrSink));
+  const { code, signal } = await new Promise((resolve) => {
+    child.on("close", (code2, signal2) => resolve({ code: code2, signal: signal2 }));
+  });
+  heartbeat.stop();
+  clearTimeout(timeoutHandle);
+  let stdoutText = stdoutSink.text();
+  let stderrText = stderrSink.text();
+  if (overflowed) {
+    stdoutText += `
+[token-goat: capture capped at ${MAX_CAPTURE_BYTES / (1024 * 1024)} MiB]`;
+  }
+  let exitCode;
+  if (timedOut) {
+    exitCode = 124;
+    stderrText = (stderrText ? stderrText + "\n" : "") + `[token-goat: command exceeded ${timeout}s timeout and was killed]`;
+  } else if (code !== null) {
+    exitCode = code;
+  } else if (signal) {
+    exitCode = signalExitCode(signal);
+  } else {
+    exitCode = 0;
+  }
+  if (opts.quietSuccess && exitCode === 0) {
+    const duration = ((Date.now() - startTime) / 1e3).toFixed(1) + "s";
+    const fullRaw = (stdoutText + (stderrText ? "\n" + stderrText : "")).trim();
+    const id = storeBashOutputSync(command, fullRaw, 0, opts.cwd ?? null);
+    const summary = `[tg: ok] ${command} (${duration}, recall: token-goat bash-output ${id})
+`;
+    writeStdout(summary);
+    return 0;
+  }
+  const limits = resolveCompressLimits();
+  const { applied, marker, compressed, text: delivered } = deliverCompressed(filter, stdoutText, stderrText, exitCode, argv, {
+    compressionProfile: profile,
+    maxLines: limits.maxLines,
+    maxBytes: limits.maxBytes
+  });
+  let text = delivered;
+  const maxTokens = opts.maxTokens ?? 0;
+  if (maxTokens > 0) text = capTokens(text, maxTokens);
+  let body = text + marker;
+  if (applied) {
+    const fullRaw = (stdoutText + (stderrText ? "\n" + stderrText : "")).trim();
+    const recallId = storeBashOutputSync(command, fullRaw, exitCode, opts.cwd ?? null);
+    body += "\n[token-goat] full output: bash-output " + recallId + " --full";
+  }
+  writeStdout(body.endsWith("\n") ? body : body + "\n");
+  if (applied) recordSavings(compressed);
+  return exitCode;
+}
+function recordSavings(result) {
+  const delivered = deliveredOutputBytes(result.originalBytes);
+  const bytesSaved = Math.max(0, delivered - result.compressedBytes);
+  if (bytesSaved < MIN_RECORD_STAT_BYTES) return;
+  recordStat(`bash_compress:${result.filterName}`, bytesSaved, compressedTokensSaved(bytesSaved));
+}
+
+export {
+  clipToDeliveryCap,
+  deliveredOutputBytes,
+  canRunWrappedShell,
+  DEFAULT_TIMEOUT_SECONDS,
+  MAX_CAPTURE_BYTES,
+  DEFAULT_HEARTBEAT_INTERVAL_MS,
+  resolveFilter,
+  run,
+  runRaw
+};

package/dist/{token-goat-chunk-I67CPTDD.mjs → token-goat-chunk-K3ZNBN4U.mjs}

@@ -2,15 +2,15 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   getDb
-} from "./token-goat-chunk-L7VCX33I.mjs";
+} from "./token-goat-chunk-T63VHOL3.mjs";
 import {
   foldPath,
   globalDbPath,
   isCaseInsensitiveFs
-} from "./token-goat-chunk-QIDLJGXZ.mjs";
+} from "./token-goat-chunk-6LJNM4ZZ.mjs";
 import {
   normalizePath
-} from "./token-goat-chunk-ERTXEKB6.mjs";
+} from "./token-goat-chunk-NMTKNYGF.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -50,6 +50,9 @@ function projectScopeClause(column) {
 }
 
 // src/index_reader.ts
+function indexKey(p) {
+  return normalizePath(p);
+}
 function toSymbolEntry(row) {
   return {
     filePath: row.file_path,
@@ -75,7 +78,7 @@ function applyRootDirScope(rootDir, column, where, params) {
   if (rootDir === void 0) return;
   const { clause, params: bounds } = projectScopeClause(column);
   where.push(clause);
-  params.push(...bounds(rootDir));
+  params.push(...bounds(indexKey(rootDir)));
 }
 function buildSymbolWhere(opts) {
   const where = [];
@@ -85,13 +88,14 @@ function buildSymbolWhere(opts) {
     params.push(opts.name);
   }
   if (opts.filePath !== void 0) {
-    if (opts.filePath.includes("/") || opts.filePath.includes("\\")) {
-      const alt = opts.filePath.includes("/") ? opts.filePath.replace(/\//g, "\\") : opts.filePath.replace(/\\/g, "/");
+    const key = indexKey(opts.filePath);
+    if (key.includes("/") || key.includes("\\")) {
+      const alt = key.includes("/") ? key.replace(/\//g, "\\") : key.replace(/\\/g, "/");
       where.push(`(${pathEqClause("file_path")} OR ${pathEqClause("file_path")})`);
-      params.push(foldPath(opts.filePath), foldPath(alt));
+      params.push(foldPath(key), foldPath(alt));
     } else {
       where.push(pathEqClause("file_path"));
-      params.push(foldPath(opts.filePath));
+      params.push(foldPath(key));
     }
   }
   if (opts.kind !== void 0) {
@@ -141,7 +145,7 @@ function buildRefsWhere(opts) {
   const params = [opts.name];
   if (opts.filePath !== void 0) {
     where.push(pathEqClause("file_path"));
-    params.push(foldPath(opts.filePath));
+    params.push(foldPath(indexKey(opts.filePath)));
   }
   applyRootDirScope(opts.rootDir, "file_path", where, params);
   return { clause: `WHERE ${where.join(" AND ")}`, params };
@@ -164,7 +168,7 @@ function countRefs(opts, dbPath = globalDbPath()) {
 function queryRefsByContext(context, filePath, dbPath = globalDbPath()) {
   const sql = `SELECT file_path, name, line, col, context FROM refs WHERE context = ? AND ${pathEqClause("file_path")} ORDER BY line LIMIT 20`;
   const db = getDb(dbPath);
-  const rows = db.prepare(sql).all(context, foldPath(filePath));
+  const rows = db.prepare(sql).all(context, foldPath(indexKey(filePath)));
   return rows.map(toRefEntry);
 }
 var REF_COUNT_BATCH = 900;
@@ -192,7 +196,7 @@ function queryRefCounts(names, dbPath = globalDbPath(), rootDir) {
 function getProjectFileEntries(rootDir, dbPath = globalDbPath()) {
   const db = getDb(dbPath);
   const { clause, params } = projectScopeClause("path");
-  const rows = db.prepare(`SELECT path, sha, mtime, language, indexed_at, embed_sha, parser_sha FROM files WHERE ${clause}`).all(...params(rootDir));
+  const rows = db.prepare(`SELECT path, sha, mtime, language, indexed_at, embed_sha, parser_sha FROM files WHERE ${clause}`).all(...params(indexKey(rootDir)));
   const out = /* @__PURE__ */ new Map();
   for (const row of rows) {
     out.set(foldPath(row.path), {
@@ -209,11 +213,12 @@ function getProjectFileEntries(rootDir, dbPath = globalDbPath()) {
 }
 function getFileEntry(filePath, dbPath = globalDbPath()) {
   const db = getDb(dbPath);
+  const key = indexKey(filePath);
   let row = db.prepare(
     `SELECT path, sha, mtime, language, indexed_at, embed_sha, parser_sha FROM files WHERE ${pathEqClause("path")}`
-  ).get(foldPath(filePath));
-  if (row === void 0 && (filePath.includes("/") || filePath.includes("\\"))) {
-    const altPath = filePath.includes("/") ? filePath.replace(/\//g, "\\") : filePath.replace(/\\/g, "/");
+  ).get(foldPath(key));
+  if (row === void 0 && (key.includes("/") || key.includes("\\"))) {
+    const altPath = key.includes("/") ? key.replace(/\//g, "\\") : key.replace(/\\/g, "/");
     row = db.prepare(
       `SELECT path, sha, mtime, language, indexed_at, embed_sha, parser_sha FROM files WHERE ${pathEqClause("path")}`
     ).get(foldPath(altPath));