@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-QG6I2T5E.js

@@ -0,0 +1,1416 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  createSlicer
+} from "./chunk-KPRLAMP4.js";
+import {
+  CODEWIKI_VERSION,
+  readCodewiki,
+  readCodewikiAsync
+} from "./chunk-W2RJEH6Q.js";
+import {
+  WORKSPACE_EXCLUDED_DIRS,
+  enumerateWorkspaceFiles,
+  enumerateWorkspaceFilesAsync,
+  filterWorkspaceFileCandidates
+} from "./chunk-PPEZJWUG.js";
+import {
+  classifyCHeaderLanguage,
+  isAmbiguousHeaderPath
+} from "./chunk-WDV62RKY.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/context/fingerprint.ts
+init_esm_shims();
+import { execFile, execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+// src/domains/context/codewiki/paths.ts
+init_esm_shims();
+
+// src/domains/context/excluded-dirs.ts
+init_esm_shims();
+
+// src/domains/context/codewiki/paths.ts
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Map([
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".mts", "typescript"],
+  [".cts", "typescript"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".py", "python"],
+  [".pyw", "python"],
+  [".rs", "rust"],
+  [".go", "go"],
+  [".c", "c"],
+  [".h", "c"],
+  [".cc", "c++"],
+  [".cpp", "c++"],
+  [".cxx", "c++"],
+  [".hpp", "c++"],
+  [".hh", "c++"],
+  [".hxx", "c++"],
+  [".cu", "c++"],
+  [".cuh", "c++"],
+  [".java", "java"],
+  [".rb", "ruby"],
+  [".cs", "c#"]
+]);
+var CONFIG_FILE_NAMES = /* @__PURE__ */ new Set([
+  "package.json",
+  "pyproject.toml",
+  "setup.py",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "CMakeLists.txt",
+  "compile_commands.json",
+  "Gemfile"
+]);
+function extensionOf(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function sourceLanguageForPath(relPath) {
+  if (relPath.endsWith(".d.ts")) return null;
+  return SOURCE_EXTENSIONS.get(extensionOf(relPath)) ?? null;
+}
+function languageForPath(relPath) {
+  const source = sourceLanguageForPath(relPath);
+  if (source) return source;
+  const name = relPath.split("/").pop() ?? relPath;
+  return CONFIG_FILE_NAMES.has(name) || name.endsWith(".csproj") || name.toLowerCase().endsWith(".cmake") ? "config" : null;
+}
+function isIndexablePath(relPath) {
+  if (relPath.split("/").some((segment) => WORKSPACE_EXCLUDED_DIRS.has(segment))) return false;
+  return languageForPath(relPath) !== null;
+}
+
+// src/domains/context/fingerprint.ts
+var execFileAsync = promisify(execFile);
+var DEFAULT_FINGERPRINT_CACHE_TTL_MS = 5e3;
+var cachedFingerprints = /* @__PURE__ */ new Map();
+var LOC_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rs",
+  ".go",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".hpp",
+  ".hh",
+  ".hxx",
+  ".c",
+  ".h",
+  ".cu",
+  ".cuh",
+  ".java",
+  ".kt"
+]);
+function extensionOf2(name) {
+  const index = name.lastIndexOf(".");
+  return index === -1 ? "" : name.slice(index);
+}
+function currentGitHead(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+async function currentGitHeadAsync(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd, encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function countLines(text) {
+  if (text.length === 0) return 0;
+  let lines = 1;
+  for (const ch of text) {
+    if (ch === "\n") lines += 1;
+  }
+  return lines;
+}
+function locFromCodewiki(codewiki) {
+  if (!codewiki) return null;
+  return codewiki.files.reduce((sum, file) => file.lang === "config" ? sum : sum + file.loc, 0);
+}
+function createTreeHash() {
+  return createHash("sha256").update("clio-codewiki-tree:v3\n");
+}
+function accumulateFile(cwd, relPath, hash, artifactLoc) {
+  const contents = readFileSync(join(cwd, relPath));
+  const digest = createHash("sha256").update(contents).digest("hex");
+  hash.update(`${JSON.stringify(relPath)}:${digest}
+`);
+  if (artifactLoc === null && LOC_EXTENSIONS.has(extensionOf2(relPath))) return countLines(contents.toString("utf8"));
+  return 0;
+}
+function computeFingerprint(cwd, codewiki = readCodewiki(cwd), options = {}) {
+  const files = enumerateWorkspaceFiles(cwd, WORKSPACE_EXCLUDED_DIRS).filter(isIndexablePath);
+  const hash = createTreeHash();
+  const artifactLoc = options.artifactLoc ?? locFromCodewiki(codewiki);
+  let loc = 0;
+  for (const relPath of files) loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+  return {
+    treeHash: hash.digest("hex"),
+    gitHead: currentGitHead(cwd),
+    loc: artifactLoc ?? loc
+  };
+}
+async function computeFingerprintAsync(cwd, codewiki = void 0, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const artifact = codewiki === void 0 ? await readCodewikiAsync(cwd) : codewiki;
+  await slicer.tick();
+  const files = (await enumerateWorkspaceFilesAsync(cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer)).filter(isIndexablePath);
+  const hash = createTreeHash();
+  const artifactLoc = locFromCodewiki(artifact);
+  let loc = 0;
+  for (const relPath of files) {
+    await slicer.tick();
+    loc += accumulateFile(cwd, relPath, hash, artifactLoc);
+  }
+  return {
+    treeHash: hash.digest("hex"),
+    gitHead: await currentGitHeadAsync(cwd),
+    loc: artifactLoc ?? loc
+  };
+}
+function computeFingerprintCached(cwd, codewiki = readCodewiki(cwd), options = {}) {
+  const now = Date.now();
+  const cached = cachedFingerprints.get(cwd);
+  if (cached && cached.expiresAtMs > now) return cached.fingerprint;
+  const fingerprint = computeFingerprint(cwd, codewiki, options);
+  const ttlMs = options.ttlMs ?? DEFAULT_FINGERPRINT_CACHE_TTL_MS;
+  cachedFingerprints.set(cwd, {
+    fingerprint,
+    expiresAtMs: Date.now() + Math.max(0, ttlMs)
+  });
+  return fingerprint;
+}
+function isStale(prev, curr) {
+  return prev.treeHash !== curr.treeHash;
+}
+
+// src/domains/context/codewiki/indexer.ts
+init_esm_shims();
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { dirname, join as join2, relative, resolve } from "node:path";
+
+// src/domains/context/codewiki/cmake.ts
+init_esm_shims();
+var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  ".c",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".cu",
+  ".cuh",
+  ".h",
+  ".hh",
+  ".hpp",
+  ".hxx",
+  ".java",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".py",
+  ".pyw",
+  ".rb",
+  ".rs",
+  ".cs",
+  ".ts",
+  ".tsx"
+]);
+var TARGET_SOURCE_KEYWORDS = /* @__PURE__ */ new Set([
+  "PUBLIC",
+  "PRIVATE",
+  "INTERFACE",
+  "BEFORE",
+  "FILE_SET",
+  "TYPE",
+  "BASE_DIRS",
+  "FILES"
+]);
+function compareStrings(a, b) {
+  return a.localeCompare(b);
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort(compareStrings);
+}
+function lineStarts(text) {
+  const starts = [0];
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === "\n") starts.push(index + 1);
+  }
+  return starts;
+}
+function lineAt(starts, offset) {
+  let low = 0;
+  let high = starts.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if ((starts[middle] ?? 0) <= offset) low = middle + 1;
+    else high = middle;
+  }
+  return Math.max(1, low);
+}
+function readBracketBlock(text, index) {
+  if (text[index] !== "[") return null;
+  let delimiterEnd = index + 1;
+  while (text[delimiterEnd] === "=") delimiterEnd += 1;
+  if (text[delimiterEnd] !== "[") return null;
+  const equals = text.slice(index + 1, delimiterEnd);
+  const close = `]${equals}]`;
+  const contentStart = delimiterEnd + 1;
+  const closeStart = text.indexOf(close, contentStart);
+  if (closeStart === -1) return null;
+  return {
+    content: text.slice(contentStart, closeStart),
+    end: closeStart + close.length
+  };
+}
+function skipComment(text, index) {
+  const bracket = readBracketBlock(text, index + 1);
+  if (bracket) return bracket.end;
+  const newline = text.indexOf("\n", index + 1);
+  return newline === -1 ? text.length : newline + 1;
+}
+function skipTrivia(text, start) {
+  let index = start;
+  while (index < text.length) {
+    if (/\s/.test(text[index] ?? "")) {
+      index += 1;
+      continue;
+    }
+    if (text[index] === "#") {
+      index = skipComment(text, index);
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+function readQuotedArgument(text, start) {
+  let content = "";
+  for (let index = start + 1; index < text.length; index += 1) {
+    const current = text[index] ?? "";
+    if (current === '"') return { content, end: index + 1 };
+    if (current === "\\") {
+      const next = text[index + 1];
+      if (next === void 0) return null;
+      if (next === "\n") {
+        index += 1;
+        continue;
+      }
+      content += next;
+      index += 1;
+      continue;
+    }
+    content += current;
+  }
+  return null;
+}
+function parseInvocation(text, name, line, openParen) {
+  const args = [];
+  let current = "";
+  let depth = 1;
+  let index = openParen + 1;
+  const flush = () => {
+    if (current.length > 0) args.push(current);
+    current = "";
+  };
+  while (index < text.length) {
+    const char = text[index] ?? "";
+    if (/\s/.test(char)) {
+      flush();
+      index += 1;
+      continue;
+    }
+    if (char === "#") {
+      flush();
+      index = skipComment(text, index);
+      continue;
+    }
+    if (char === '"') {
+      const quoted = readQuotedArgument(text, index);
+      if (!quoted) return null;
+      current += quoted.content;
+      index = quoted.end;
+      continue;
+    }
+    if (char === "[") {
+      const bracket = readBracketBlock(text, index);
+      if (bracket) {
+        current += bracket.content;
+        index = bracket.end;
+        continue;
+      }
+    }
+    if (char === "\\") {
+      const next = text[index + 1];
+      if (next === void 0) return null;
+      if (next === "\n") {
+        index += 2;
+        continue;
+      }
+      current += next;
+      index += 2;
+      continue;
+    }
+    if (char === ";" && depth === 1) {
+      flush();
+      index += 1;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+      current += char;
+      index += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        flush();
+        return {
+          invocation: { name, line, args },
+          end: index + 1
+        };
+      }
+      current += char;
+      index += 1;
+      continue;
+    }
+    current += char;
+    index += 1;
+  }
+  return null;
+}
+function scanInvocations(text) {
+  const invocations = [];
+  const starts = lineStarts(text);
+  let index = 0;
+  while (index < text.length) {
+    index = skipTrivia(text, index);
+    if (index >= text.length) break;
+    if (text[index] === '"') {
+      const quoted = readQuotedArgument(text, index);
+      index = quoted?.end ?? text.length;
+      continue;
+    }
+    if (text[index] === "[") {
+      const bracket = readBracketBlock(text, index);
+      if (bracket) {
+        index = bracket.end;
+        continue;
+      }
+    }
+    const name = /^[A-Za-z_][A-Za-z_0-9]*/.exec(text.slice(index))?.[0];
+    if (!name) {
+      index += 1;
+      continue;
+    }
+    const nameStart = index;
+    const openParen = skipTrivia(text, index + name.length);
+    if (text[openParen] !== "(") {
+      index += name.length;
+      continue;
+    }
+    const parsed = parseInvocation(text, name.toLowerCase(), lineAt(starts, nameStart), openParen);
+    if (!parsed) {
+      index = openParen + 1;
+      continue;
+    }
+    invocations.push(parsed.invocation);
+    index = parsed.end;
+  }
+  return invocations;
+}
+function literal(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.includes("$")) return null;
+  return trimmed.replace(/\\/g, "/");
+}
+function literalTarget(value) {
+  const target = literal(value);
+  return target && /^[A-Za-z0-9_.:+-]+$/.test(target) ? target : null;
+}
+function relativeSpecifier(value) {
+  if (value.startsWith("/") || /^[A-Za-z]:\//.test(value)) return null;
+  const normalized = value.replace(/^\.\//, "").replace(/\/+$/g, "");
+  if (normalized.length === 0) return null;
+  return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+function sourceSpecifier(value) {
+  const path = literal(value);
+  if (!path || path.includes(";") || path.startsWith("-") || TARGET_SOURCE_KEYWORDS.has(path.toUpperCase())) return null;
+  const withoutQuery = path.split(/[?#]/, 1)[0] ?? path;
+  const dot = withoutQuery.lastIndexOf(".");
+  if (dot === -1 || !SOURCE_EXTENSIONS2.has(withoutQuery.slice(dot).toLowerCase())) return null;
+  return relativeSpecifier(path);
+}
+function childCMakeSpecifier(value) {
+  const directory = literal(value);
+  if (!directory) return null;
+  const relative2 = relativeSpecifier(directory);
+  if (!relative2) return null;
+  return `${relative2}/CMakeLists.txt`.replace(/\/\//g, "/");
+}
+function isCMakePath(path) {
+  const name = path.split("/").at(-1) ?? path;
+  return name === "CMakeLists.txt" || name.toLowerCase().endsWith(".cmake");
+}
+function extractCMake(text) {
+  const symbols = [];
+  const imports = [];
+  for (const invocation of scanInvocations(text)) {
+    if (invocation.name === "add_subdirectory") {
+      const child = childCMakeSpecifier(invocation.args[0]);
+      if (child) imports.push(child);
+      continue;
+    }
+    if (invocation.name === "add_library" || invocation.name === "add_executable") {
+      const target = literalTarget(invocation.args[0]);
+      if (!target) continue;
+      symbols.push({ name: target, kind: "const", line: invocation.line });
+      if (invocation.args[1]?.toUpperCase() === "ALIAS") continue;
+      for (const arg of invocation.args.slice(1)) {
+        const source = sourceSpecifier(arg);
+        if (source) imports.push(source);
+      }
+      continue;
+    }
+    if (invocation.name === "target_sources") {
+      if (!literalTarget(invocation.args[0])) continue;
+      for (const arg of invocation.args.slice(1)) {
+        const source = sourceSpecifier(arg);
+        if (source) imports.push(source);
+      }
+    }
+  }
+  return {
+    symbols: symbols.sort((a, b) => a.line - b.line || a.name.localeCompare(b.name)),
+    imports: uniqueSorted(imports)
+  };
+}
+
+// src/domains/context/codewiki/indexer.ts
+var CODEWIKI_SYMBOL_KINDS_WITH_SIG = /* @__PURE__ */ new Set(["func", "class", "method", "type"]);
+var treeSitterExtractorPromise = null;
+function loadTreeSitterExtractor() {
+  treeSitterExtractorPromise ??= import("./tree-sitter-TQW3Y52T.js").then(
+    ({ createTreeSitterExtractor }) => createTreeSitterExtractor()
+  );
+  return treeSitterExtractorPromise;
+}
+var RESOLUTION_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".c",
+  ".h",
+  ".cc",
+  ".cpp",
+  ".cxx",
+  ".hpp",
+  ".hh",
+  ".hxx",
+  ".cu",
+  ".cuh",
+  ".java",
+  ".rb",
+  ".cs"
+];
+function compareStrings2(a, b) {
+  return a.localeCompare(b);
+}
+function stableFileId(path) {
+  return `f_${createHash2("sha256").update(path).digest("hex").slice(0, 16)}`;
+}
+function contentHash(text) {
+  return createHash2("sha256").update(text).digest("hex").slice(0, 16);
+}
+function defaultReadFile(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function normalizeRel(cwd, filePath) {
+  return relative(cwd, filePath).split("\\").join("/");
+}
+function normalizeInputPath(path) {
+  return path.split("\\").join("/").replace(/^\.\//, "");
+}
+function lineCount(text) {
+  if (text.length === 0) return 0;
+  return text.endsWith("\n") ? text.split("\n").length - 1 : text.split("\n").length;
+}
+function roleFor(relPath, language) {
+  if (language === "config") return "config";
+  const lower = relPath.toLowerCase();
+  if (lower.includes("/test/") || lower.includes("/tests/") || /\.(test|spec)\.[cm]?[jt]sx?$/.test(lower) || /(^|\/)test_.*\.py$/.test(lower) || /(^|\/).*_test\.(go|rs|rb)$/.test(lower)) {
+    return "test";
+  }
+  if (/(^|\/)(index|main|server|cli|orchestrator|bootstrap)\.[^.]+$/.test(lower) || lower.endsWith("/__main__.py")) {
+    return "entry";
+  }
+  return "module";
+}
+function firstDocSummary(text) {
+  const jsDoc = /\/\*\*([\s\S]*?)\*\//.exec(text)?.[1];
+  const pythonDoc = /^\s*(?:"""([\s\S]*?)"""|'''([\s\S]*?)''')/.exec(text);
+  const raw = jsDoc ?? pythonDoc?.[1] ?? pythonDoc?.[2];
+  if (!raw) return null;
+  const cleaned = raw.split("\n").map((line) => line.replace(/^\s*\*\s?/, "").trim()).filter((line) => line.length > 0 && !line.startsWith("@")).join(" ").replace(/\s+/g, " ").trim();
+  return cleaned.length > 0 ? cleaned.slice(0, 160) : null;
+}
+function sanitizeSymbolName(value) {
+  return value.trim().replace(/^self\./, "").replace(/^this\./, "").slice(0, 160);
+}
+function addSymbol(target, seen, name, kind, line, sig) {
+  if (!name) return;
+  const clean = sanitizeSymbolName(name);
+  if (clean.length === 0) return;
+  const key = `${clean}\0${kind}\0${line}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  target.push({
+    name: clean,
+    kind,
+    line,
+    ...sig && sig.trim().length > 0 ? { sig: sig.trim().slice(0, 240) } : {}
+  });
+}
+function uniqueSorted2(values) {
+  return [...new Set([...values].filter((item) => item.length > 0))].sort(compareStrings2);
+}
+function extractWithLineRegex(text, patterns) {
+  const symbols = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = text.split(/\r?\n/);
+  for (const [index, line] of lines.entries()) {
+    for (const pattern of patterns) {
+      const match = pattern.regex.exec(line);
+      if (!match) continue;
+      const name = match[pattern.nameIndex ?? 1];
+      addSymbol(symbols, seen, name, pattern.kind, index + 1, line.trim());
+    }
+  }
+  return symbols.sort(compareSymbols);
+}
+function compareSymbols(a, b) {
+  return a.line - b.line || a.name.localeCompare(b.name) || a.kind.localeCompare(b.kind);
+}
+function extractMatches(text, regex, group = 1) {
+  const out = [];
+  for (const match of text.matchAll(regex)) {
+    const value = match[group];
+    if (value) out.push(value);
+  }
+  return out;
+}
+function maskCFamilyCommentsAndStrings(text) {
+  const chars = text.split("");
+  let state = "code";
+  for (let index = 0; index < chars.length; index += 1) {
+    const current = chars[index] ?? "";
+    const next = chars[index + 1] ?? "";
+    if (state === "code") {
+      if (current === "/" && next === "/") {
+        chars[index] = " ";
+        chars[index + 1] = " ";
+        state = "line-comment";
+        index += 1;
+      } else if (current === "/" && next === "*") {
+        chars[index] = " ";
+        chars[index + 1] = " ";
+        state = "block-comment";
+        index += 1;
+      } else if (current === "'") {
+        chars[index] = " ";
+        state = "single-quote";
+      } else if (current === '"') {
+        chars[index] = " ";
+        state = "double-quote";
+      }
+      continue;
+    }
+    if (current === "\n") {
+      if (state === "line-comment") state = "code";
+      continue;
+    }
+    chars[index] = " ";
+    if (state === "block-comment" && current === "*" && next === "/") {
+      chars[index + 1] = " ";
+      state = "code";
+      index += 1;
+      continue;
+    }
+    if ((state === "single-quote" || state === "double-quote") && current === "\\") {
+      if (index + 1 < chars.length && chars[index + 1] !== "\n") {
+        chars[index + 1] = " ";
+        index += 1;
+      }
+      continue;
+    }
+    if (state === "single-quote" && current === "'") state = "code";
+    if (state === "double-quote" && current === '"') state = "code";
+  }
+  return chars.join("");
+}
+function cFamilyAliasStatements(text) {
+  const masked = maskCFamilyCommentsAndStrings(text);
+  const statements = [];
+  const token = /\b(?:typedef|using)\b/g;
+  for (let match = token.exec(masked); match; match = token.exec(masked)) {
+    const start = match.index;
+    const lineStart = masked.lastIndexOf("\n", start - 1) + 1;
+    if (masked.slice(lineStart, start).trimStart().startsWith("#")) continue;
+    let braces = 0;
+    let parentheses = 0;
+    let brackets = 0;
+    let end = -1;
+    for (let index = token.lastIndex; index < masked.length; index += 1) {
+      const current = masked[index];
+      if (current === "{") braces += 1;
+      else if (current === "}") braces = Math.max(0, braces - 1);
+      else if (current === "(") parentheses += 1;
+      else if (current === ")") parentheses = Math.max(0, parentheses - 1);
+      else if (current === "[") brackets += 1;
+      else if (current === "]") brackets = Math.max(0, brackets - 1);
+      else if (current === ";" && braces === 0 && parentheses === 0 && brackets === 0) {
+        end = index + 1;
+        break;
+      }
+    }
+    if (end === -1) continue;
+    statements.push({
+      text: text.slice(start, end),
+      masked: masked.slice(start, end),
+      line: 1 + Array.from(masked.slice(0, start).matchAll(/\n/g)).length
+    });
+    token.lastIndex = end;
+  }
+  return statements;
+}
+function stripCFamilyBraceBodies(statement) {
+  let depth = 0;
+  let result = "";
+  for (const current of statement) {
+    if (current === "{") {
+      depth += 1;
+      result += " ";
+      continue;
+    }
+    if (current === "}") {
+      depth = Math.max(0, depth - 1);
+      result += " ";
+      continue;
+    }
+    result += depth === 0 || current === "\n" ? current : " ";
+  }
+  return result;
+}
+function splitCFamilyDeclarators(value) {
+  const parts = [];
+  let start = 0;
+  let parentheses = 0;
+  let brackets = 0;
+  let angles = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const current = value[index];
+    if (current === "(") parentheses += 1;
+    else if (current === ")") parentheses = Math.max(0, parentheses - 1);
+    else if (current === "[") brackets += 1;
+    else if (current === "]") brackets = Math.max(0, brackets - 1);
+    else if (current === "<") angles += 1;
+    else if (current === ">") angles = Math.max(0, angles - 1);
+    else if (current === "," && parentheses === 0 && brackets === 0 && angles === 0) {
+      parts.push(value.slice(start, index));
+      start = index + 1;
+    }
+  }
+  parts.push(value.slice(start));
+  return parts;
+}
+var C_FAMILY_TYPE_WORDS = /* @__PURE__ */ new Set([
+  "typedef",
+  "const",
+  "volatile",
+  "restrict",
+  "signed",
+  "unsigned",
+  "short",
+  "long",
+  "void",
+  "char",
+  "int",
+  "float",
+  "double",
+  "struct",
+  "union",
+  "enum",
+  "class",
+  "typename",
+  "auto"
+]);
+function stripTrailingCFamilyDeclaratorSuffixes(value) {
+  let end = value.length;
+  while (end > 0) {
+    while (end > 0 && /\s/.test(value[end - 1] ?? "")) end -= 1;
+    const close = value[end - 1];
+    if (close !== ")" && close !== "]") break;
+    const open = close === ")" ? "(" : "[";
+    let depth = 1;
+    let start = end - 1;
+    for (start -= 1; start >= 0; start -= 1) {
+      const current = value[start];
+      if (current === close) depth += 1;
+      else if (current === open) {
+        depth -= 1;
+        if (depth === 0) break;
+      }
+    }
+    if (start < 0) break;
+    if (start === 0 || !/[A-Za-z_0-9)\]]/.test(value[start - 1] ?? "")) break;
+    end = start;
+  }
+  return value.slice(0, end);
+}
+function cFamilyTypedefNames(maskedStatement) {
+  const withoutBodies = stripCFamilyBraceBodies(maskedStatement).replace(/^\s*typedef\b/, "").replace(/;\s*$/, "");
+  const names = [];
+  for (const declarator of splitCFamilyDeclarators(withoutBodies)) {
+    const functionPointerNames = Array.from(
+      declarator.matchAll(
+        /\(\s*(?:[A-Za-z_]\w*\s+)*[*&]+\s*(?:(?:const|volatile|restrict)\s+)*([A-Za-z_]\w*)\s*(?:\[[^\]]*\]\s*)*\)(?=\s*\()/g
+      ),
+      (match) => match[1] ?? ""
+    ).filter((name2) => name2.length > 0);
+    if (functionPointerNames.length > 0) {
+      names.push(...functionPointerNames);
+      continue;
+    }
+    const declaratorWithoutSuffixes = stripTrailingCFamilyDeclaratorSuffixes(declarator);
+    const identifiers = Array.from(declaratorWithoutSuffixes.matchAll(/\b[A-Za-z_]\w*\b/g), (match) => match[0]).filter(
+      (name2) => !C_FAMILY_TYPE_WORDS.has(name2)
+    );
+    const name = identifiers.at(-1);
+    if (name) names.push(name);
+  }
+  return uniqueSorted2(names);
+}
+function extractCFamilyAliasSymbols(text) {
+  const symbols = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const statement of cFamilyAliasStatements(text)) {
+    const usingName = /^\s*using\s+([A-Za-z_]\w*)\s*=/.exec(statement.masked)?.[1];
+    const names = usingName ? [usingName] : /^\s*typedef\b/.test(statement.masked) ? cFamilyTypedefNames(statement.masked) : [];
+    const signature = statement.text.replace(/\s+/g, " ").trim();
+    for (const name of names) addSymbol(symbols, seen, name, "type", statement.line, signature);
+  }
+  return symbols;
+}
+var tsJsExtractor = {
+  langs: ["typescript", "javascript"],
+  extractImports(_path, text) {
+    return uniqueSorted2([
+      ...extractMatches(text, /\bimport\s+(?:type\s+)?(?:[^'"]*?\s+from\s+)?["']([^"']+)["']/g),
+      ...extractMatches(text, /\bexport\s+[^'"]*?\s+from\s+["']([^"']+)["']/g),
+      ...extractMatches(text, /\brequire\s*\(\s*["']([^"']+)["']\s*\)/g),
+      ...extractMatches(text, /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g)
+    ]);
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      { regex: /^\s*export\s+default\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)?/, kind: "func" },
+      { regex: /^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/, kind: "func" },
+      { regex: /^\s*(?:export\s+)?class\s+([A-Za-z_$][\w$]*)\b/, kind: "class" },
+      { regex: /^\s*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)\b/, kind: "iface" },
+      { regex: /^\s*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\b/, kind: "type" },
+      { regex: /^\s*(?:export\s+)?enum\s+([A-Za-z_$][\w$]*)\b/, kind: "type" },
+      { regex: /^(?:\s*export\s+)?const\s+([A-Za-z_$][\w$]*)\b/, kind: "const" },
+      { regex: /^(?:\s*export\s+)?(?:let|var)\s+([A-Za-z_$][\w$]*)\b/, kind: "var" },
+      {
+        regex: /^(?: {2,}|\t+)(?:public\s+|private\s+|protected\s+|static\s+|override\s+|abstract\s+|async\s+|get\s+|set\s+)*(?!(?:if|for|while|switch|catch|return|typeof|else|do|new|await|yield)\b)([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*\{?$/,
+        kind: "method"
+      }
+    ]);
+    return { symbols, imports: tsJsExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var pythonExtractor = {
+  langs: ["python"],
+  extractImports(_path, text) {
+    return uniqueSorted2([
+      ...extractMatches(text, /^\s*import\s+([A-Za-z_][\w.]*)(?:\s+as\s+\w+)?/gm),
+      ...extractMatches(text, /^\s*from\s+([.\w]+)\s+import\s+/gm)
+    ]);
+  },
+  extract(_path, text) {
+    const rawSymbols = extractWithLineRegex(text, [
+      { regex: /^(\s*)def\s+([A-Za-z_]\w*)\s*\(/, kind: "func", nameIndex: 2 },
+      { regex: /^(\s*)async\s+def\s+([A-Za-z_]\w*)\s*\(/, kind: "func", nameIndex: 2 },
+      { regex: /^\s*class\s+([A-Za-z_]\w*)\b/, kind: "class" },
+      { regex: /^([A-Z][A-Z0-9_]*)\s*=/, kind: "const" },
+      { regex: /^([A-Za-z_]\w*)\s*=/, kind: "var" }
+    ]);
+    const symbols = rawSymbols.map((symbol) => {
+      if ((symbol.kind === "func" || symbol.kind === "var") && /^\s+/.test(symbol.sig ?? "")) {
+        return { ...symbol, kind: symbol.kind === "func" ? "method" : symbol.kind };
+      }
+      return symbol;
+    });
+    return { symbols: symbols.sort(compareSymbols), imports: pythonExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var goExtractor = {
+  langs: ["go"],
+  extractImports(_path, text) {
+    return uniqueSorted2([
+      ...extractMatches(text, /^\s*import\s+"([^"]+)"/gm),
+      ...extractMatches(text, /^\s*"([^"]+)"\s*$/gm)
+    ]);
+  },
+  extract(_path, text) {
+    const rawSymbols = extractWithLineRegex(text, [
+      { regex: /^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/, kind: "func" },
+      { regex: /^\s*type\s+([A-Za-z_]\w*)\s+interface\b/, kind: "iface" },
+      { regex: /^\s*type\s+([A-Za-z_]\w*)\s+struct\b/, kind: "type" },
+      { regex: /^\s*type\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      { regex: /^const\s+([A-Za-z_]\w*)\b/, kind: "const" },
+      { regex: /^var\s+([A-Za-z_]\w*)\b/, kind: "var" }
+    ]);
+    const symbols = rawSymbols.map((symbol) => {
+      if (symbol.kind === "func" && /^\s*func\s+\(/.test(symbol.sig ?? "")) return { ...symbol, kind: "method" };
+      return symbol;
+    });
+    return { symbols: symbols.sort(compareSymbols), imports: goExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var rustExtractor = {
+  langs: ["rust"],
+  extractImports(_path, text) {
+    return uniqueSorted2([
+      ...extractMatches(text, /^\s*use\s+([^;]+);/gm).map((item) => item.trim()),
+      ...extractMatches(text, /^\s*extern\s+crate\s+([A-Za-z_]\w*)/gm)
+    ]);
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?fn\s+([A-Za-z_]\w*)\s*[<(]/, kind: "func" },
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?trait\s+([A-Za-z_]\w*)\b/, kind: "trait" },
+      { regex: /^\s*(?:pub(?:\([^)]*\))?\s+)?type\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      { regex: /^(?:\s*pub(?:\([^)]*\))?\s+)?const\s+([A-Za-z_]\w*)\b/, kind: "const" },
+      { regex: /^(?:\s*pub(?:\([^)]*\))?\s+)?static\s+([A-Za-z_]\w*)\b/, kind: "var" }
+    ]);
+    return { symbols, imports: rustExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var cFamilyExtractor = {
+  langs: ["c", "c++"],
+  extractImports(_path, text) {
+    const imports = [];
+    for (const match of text.matchAll(/^\s*#\s*include\s*(?:"([^"]+)"|<([^>]+)>)/gm)) {
+      const quoted = match[1];
+      const system = match[2];
+      if (quoted) imports.push(quoted.startsWith(".") || quoted.startsWith("/") ? quoted : `./${quoted}`);
+      else if (system) imports.push(system);
+    }
+    return uniqueSorted2(imports);
+  },
+  extract(_path, text) {
+    const regexSymbols = extractWithLineRegex(text, [
+      { regex: /^\s*class\s+([A-Za-z_]\w*)\b/, kind: "class" },
+      {
+        regex: /^\s*(?:typedef\s+)?(?:struct\s+|union\s+|enum\s+(?:(?:class|struct)\s+)?)([A-Za-z_]\w*)\b/,
+        kind: "type"
+      },
+      {
+        regex: /^\s*(?!(?:typedef|using)\b)(?:template\s*<[^>]+>\s*)?(?:[A-Za-z_][\w:<>,*&\s]+\s+)+(?:(?:[A-Za-z_]\w*)::)*([~A-Za-z_]\w*)\s*\([^;]*\)\s*(?:const\s*)?(?:noexcept\s*)?(?:;|\{)?$/,
+        kind: "func"
+      },
+      { regex: /^(?:const\s+)?[A-Za-z_][\w:<>,*&\s]+\s+([A-Z][A-Z0-9_]*)\s*=/, kind: "const" }
+    ]);
+    const symbolsByKey = /* @__PURE__ */ new Map();
+    for (const symbol of [...regexSymbols, ...extractCFamilyAliasSymbols(text)]) {
+      const key = `${symbol.name}\0${symbol.kind}\0${symbol.line}`;
+      if (!symbolsByKey.has(key)) symbolsByKey.set(key, symbol);
+    }
+    const symbols = [...symbolsByKey.values()].sort(compareSymbols);
+    return { symbols, imports: cFamilyExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var javaExtractor = {
+  langs: ["java"],
+  extractImports(_path, text) {
+    return uniqueSorted2(extractMatches(text, /^\s*import\s+(?:static\s+)?([A-Za-z_][\w.*]*);/gm));
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      { regex: /^\s*(?:public\s+|private\s+|protected\s+|abstract\s+|final\s+)*class\s+([A-Za-z_]\w*)\b/, kind: "class" },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|abstract\s+|final\s+)*interface\s+([A-Za-z_]\w*)\b/,
+        kind: "iface"
+      },
+      { regex: /^\s*(?:public\s+|private\s+|protected\s+|abstract\s+|final\s+)*enum\s+([A-Za-z_]\w*)\b/, kind: "type" },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|static\s+|final\s+|synchronized\s+)*[A-Za-z_][\w<>,[\]\s]*\s+([A-Za-z_]\w*)\s*\([^)]*\)\s*\{?$/,
+        kind: "method"
+      },
+      {
+        regex: /^\s*public\s+(?:static\s+|final\s+)*[A-Za-z_][\w<>,[\]\s]*\s+([A-Z][A-Z0-9_]*)\s*=/,
+        kind: "const"
+      }
+    ]);
+    return { symbols, imports: javaExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var rubyExtractor = {
+  langs: ["ruby"],
+  extractImports(_path, text) {
+    return uniqueSorted2([
+      ...extractMatches(text, /^\s*require\s+["']([^"']+)["']/gm),
+      ...extractMatches(text, /^\s*require_relative\s+["']([^"']+)["']/gm).map((item) => `./${item}`)
+    ]);
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      { regex: /^\s*class\s+([A-Z]\w*(?:::[A-Z]\w*)*)\b/, kind: "class" },
+      { regex: /^\s*module\s+([A-Z]\w*(?:::[A-Z]\w*)*)\b/, kind: "type" },
+      { regex: /^\s*def\s+(?:self\.)?([A-Za-z_]\w*[!?=]?)\b/, kind: "func" },
+      { regex: /^([A-Z][A-Z0-9_]*)\s*=/, kind: "const" }
+    ]);
+    return { symbols, imports: rubyExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var csharpExtractor = {
+  langs: ["c#"],
+  extractImports(_path, text) {
+    return uniqueSorted2(
+      extractMatches(text, /^\s*using\s+(?:static\s+)?(?:[A-Za-z_]\w*\s*=\s*)?([A-Za-z_][\w.]*)\s*;/gm)
+    );
+  },
+  extract(_path, text) {
+    const symbols = extractWithLineRegex(text, [
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|static\s+|sealed\s+|abstract\s+|partial\s+)*class\s+([A-Za-z_]\w*)\b/,
+        kind: "class"
+      },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|partial\s+)*interface\s+([A-Za-z_]\w*)\b/,
+        kind: "iface"
+      },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|readonly\s+|partial\s+)*(?:enum|struct|record)\s+([A-Za-z_]\w*)\b/,
+        kind: "type"
+      },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|static\s+|virtual\s+|override\s+|abstract\s+|sealed\s+|async\s+|partial\s+|new\s+)*(?!(?:if|for|foreach|while|switch|catch|return|using|else|do|new|class|interface|enum|struct|record|namespace|lock|throw)\b)[A-Za-z_][\w<>,[\].?\s]*\s+([A-Za-z_]\w*)\s*\([^)]*\)\s*\{?$/,
+        kind: "method"
+      },
+      {
+        regex: /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|static\s+)*const\s+[A-Za-z_][\w<>,[\]\s]*\s+([A-Za-z_]\w*)\s*=/,
+        kind: "const"
+      }
+    ]);
+    return { symbols, imports: csharpExtractor.extractImports?.(_path, text) ?? [] };
+  }
+};
+var fallbackExtractors = [
+  tsJsExtractor,
+  pythonExtractor,
+  goExtractor,
+  rustExtractor,
+  cFamilyExtractor,
+  javaExtractor,
+  rubyExtractor,
+  csharpExtractor
+];
+function extractWithExtractors(extractors, language, relPath, text) {
+  const symbols = /* @__PURE__ */ new Map();
+  const imports = [];
+  for (const extractor of extractors) {
+    if (!extractor.langs.includes(language)) continue;
+    const extracted = extractor.extract(relPath, text);
+    for (const symbol of extracted.symbols) {
+      const key = `${symbol.name}\0${symbol.kind}\0${symbol.line}`;
+      if (!symbols.has(key)) symbols.set(key, symbol);
+    }
+    imports.push(...extracted.imports);
+  }
+  return {
+    symbols: [...symbols.values()].sort(compareSymbols),
+    imports: uniqueSorted2(imports)
+  };
+}
+function extractImportsWithExtractors(extractors, language, relPath, text) {
+  const imports = [];
+  for (const extractor of extractors) {
+    if (!extractor.langs.includes(language) || !extractor.extractImports) continue;
+    imports.push(...extractor.extractImports(relPath, text));
+  }
+  return uniqueSorted2(imports);
+}
+function mergeTreeSitterWithRegexImports(language, relPath, text, extracted) {
+  const regexImports = extractImportsWithExtractors(fallbackExtractors, language, relPath, text);
+  return {
+    symbols: extracted.symbols.sort(compareSymbols),
+    imports: uniqueSorted2([...extracted.imports, ...regexImports])
+  };
+}
+function fallbackExtraction(language, relPath, text) {
+  return extractWithExtractors(fallbackExtractors, language, relPath, text);
+}
+var MAX_TREE_SITTER_SOURCE_CHARS = 512 * 1024;
+function extractSourceFile(language, relPath, text, treeSitterExtractor) {
+  if (!treeSitterExtractor.langs.includes(language)) return fallbackExtraction(language, relPath, text);
+  if (text.length > MAX_TREE_SITTER_SOURCE_CHARS) return fallbackExtraction(language, relPath, text);
+  try {
+    return mergeTreeSitterWithRegexImports(language, relPath, text, treeSitterExtractor.extract(relPath, text));
+  } catch {
+    return fallbackExtraction(language, relPath, text);
+  }
+}
+function buildFile(cwd, relPath, treeSitterExtractor, readFile) {
+  const pathLanguage = languageForPath(relPath);
+  if (!pathLanguage) return null;
+  let text;
+  try {
+    text = readFile(join2(cwd, relPath));
+  } catch {
+    return null;
+  }
+  if (text === null) return null;
+  const language = pathLanguage === "c" && isAmbiguousHeaderPath(relPath) ? classifyCHeaderLanguage(text) : pathLanguage;
+  const file = {
+    id: stableFileId(relPath),
+    path: relPath,
+    lang: language,
+    loc: lineCount(text),
+    role: roleFor(relPath, language),
+    hash: contentHash(text),
+    imports: []
+  };
+  if (text.trim().length === 0) return { file, symbols: [] };
+  const extracted = isCMakePath(relPath) ? extractCMake(text) : language !== "config" ? extractSourceFile(language, relPath, text, treeSitterExtractor) : null;
+  if (!extracted) return { file, symbols: [] };
+  const summary = firstDocSummary(text);
+  const sourceFile = {
+    ...file,
+    imports: extracted.imports,
+    ...summary ? { summary } : {}
+  };
+  const symbols = extracted.symbols.map((symbol) => ({
+    name: symbol.name,
+    kind: symbol.kind,
+    fileId: sourceFile.id,
+    line: symbol.line,
+    ...symbolSigFields(symbol.kind, symbol.sig)
+  }));
+  return {
+    file: sourceFile,
+    symbols
+  };
+}
+function candidatePathsForImport(cwd, fromRel, specifier) {
+  const fromDir = dirname(join2(cwd, fromRel));
+  const cleaned = specifier.replace(/\\/g, "/");
+  const base = cleaned.startsWith(".") || cleaned.startsWith("/") ? resolve(fromDir, cleaned) : "";
+  if (!base) return [];
+  const candidates = [base];
+  for (const ext of RESOLUTION_EXTENSIONS) candidates.push(`${base}${ext}`);
+  for (const ext of RESOLUTION_EXTENSIONS) candidates.push(join2(base, `index${ext}`));
+  if (cleaned.endsWith(".js")) {
+    const stripped = base.replace(/\.js$/, "");
+    for (const ext of [".ts", ".tsx", ".mts", ".cts"]) candidates.push(`${stripped}${ext}`);
+  }
+  return uniqueSorted2(
+    candidates.map((candidate) => normalizeRel(cwd, candidate)).filter((candidate) => !candidate.startsWith(".."))
+  );
+}
+function createImportResolver(cwd) {
+  const candidatesByOrigin = /* @__PURE__ */ new Map();
+  const onDisk = /* @__PURE__ */ new Map();
+  const candidatesFor = (fromRel, specifier) => {
+    const python = /\.pyw?$/.test(fromRel);
+    const key = `${python}\0${dirname(fromRel)}\0${specifier}`;
+    let candidates = candidatesByOrigin.get(key);
+    if (!candidates) {
+      if (python) {
+        const fromDir = dirname(fromRel);
+        let packageRoot = fromDir;
+        while (packageRoot !== "." && isFile(join2(packageRoot, "__init__.py"))) {
+          packageRoot = dirname(packageRoot);
+        }
+        const dots = /^\.+/.exec(specifier)?.[0].length ?? 0;
+        const modulePath = specifier.slice(dots).replace(/\./g, "/");
+        let bases;
+        if (dots > 0) {
+          const parent = resolve(cwd, fromDir, ...Array(dots - 1).fill(".."));
+          const root = resolve(cwd, packageRoot === fromDir ? "." : packageRoot);
+          const insidePackage = parent !== root || root === resolve(cwd) && isFile("__init__.py");
+          bases = insidePackage && !relative(root, parent).startsWith("..") ? [join2(parent, modulePath)] : [];
+        } else {
+          bases = [resolve(cwd, modulePath)];
+          if (packageRoot !== fromDir && packageRoot !== ".") bases.push(resolve(cwd, packageRoot, modulePath));
+        }
+        candidates = [...new Set(bases.flatMap((base) => [join2(base, "__init__.py"), `${base}.py`]))].map(
+          (candidate) => normalizeRel(cwd, candidate)
+        );
+      } else {
+        candidates = candidatePathsForImport(cwd, fromRel, specifier);
+      }
+      candidatesByOrigin.set(key, candidates);
+    }
+    return candidates;
+  };
+  const isFile = (candidate) => {
+    const cached = onDisk.get(candidate);
+    if (cached !== void 0) return cached;
+    let exists;
+    try {
+      exists = statSync(join2(cwd, candidate)).isFile();
+    } catch {
+      exists = false;
+    }
+    onDisk.set(candidate, exists);
+    return exists;
+  };
+  return {
+    resolve(fromRel, specifier, pathToId) {
+      for (const candidate of candidatesFor(fromRel, specifier)) {
+        if (pathToId.has(candidate)) return pathToId.get(candidate) ?? null;
+        if (isFile(candidate)) return null;
+      }
+      return null;
+    }
+  };
+}
+async function buildEdges(cwd, files, slicer) {
+  const pathToId = new Map(files.map((file) => [file.path, file.id]));
+  const resolver = createImportResolver(cwd);
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    for (const specifier of file.imports) {
+      await slicer.tick();
+      const target = resolver.resolve(file.path, specifier, pathToId);
+      const edge = target ? { fileId: file.id, toFileId: target } : { fileId: file.id, externalModule: specifier };
+      const key = "toFileId" in edge ? `${edge.fileId}\0${edge.toFileId}` : `${edge.fileId}\0${edge.externalModule}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push(edge);
+    }
+  }
+  return edges.sort(compareEdges);
+}
+function compareFiles(a, b) {
+  return a.path.localeCompare(b.path);
+}
+function compareCodewikiSymbols(a, b) {
+  const pathCmp = a.fileId.localeCompare(b.fileId);
+  return pathCmp || a.line - b.line || a.name.localeCompare(b.name) || a.kind.localeCompare(b.kind);
+}
+function compareEdges(a, b) {
+  const fileCmp = a.fileId.localeCompare(b.fileId);
+  if (fileCmp !== 0) return fileCmp;
+  const aTarget = "toFileId" in a ? a.toFileId : `~${a.externalModule}`;
+  const bTarget = "toFileId" in b ? b.toFileId : `~${b.externalModule}`;
+  return aTarget.localeCompare(bTarget);
+}
+function promoteSingleSourceEntry(files) {
+  const sourceFiles = files.filter((file) => file.lang !== "config");
+  if (sourceFiles.length !== 1) return files;
+  const only = sourceFiles[0];
+  if (only?.role !== "module") return files;
+  return files.map((file) => file.id === only.id ? { ...file, role: "entry" } : file);
+}
+async function codewikiFromBuiltFiles(cwd, language, builtFiles, slicer) {
+  const baseBuiltFiles = builtFiles.map((item) => ({
+    ...item,
+    file: { ...item.file, role: roleFor(item.file.path, item.file.lang) }
+  }));
+  const files = promoteSingleSourceEntry(baseBuiltFiles.map((item) => item.file).sort(compareFiles));
+  const roleById = new Map(files.map((file) => [file.id, file.role]));
+  const normalizedBuilt = baseBuiltFiles.map((item) => {
+    const role = roleById.get(item.file.id);
+    return role && role !== item.file.role ? { ...item, file: { ...item.file, role } } : item;
+  });
+  const normalizedFiles = normalizedBuilt.map((item) => item.file).sort(compareFiles);
+  return {
+    version: CODEWIKI_VERSION,
+    language,
+    files: normalizedFiles,
+    symbols: normalizedBuilt.flatMap((item) => item.symbols).sort(compareCodewikiSymbols),
+    edges: await buildEdges(cwd, normalizedFiles, slicer)
+  };
+}
+async function buildFromPaths(cwd, language, relPaths, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const sortedPaths = [...relPaths].sort(compareStrings2);
+  const treeSitterExtractor = await loadTreeSitterExtractor();
+  await treeSitterExtractor.ensureGrammarsForPaths(sortedPaths);
+  const readFile = options.readFile ?? defaultReadFile;
+  const builtFiles = [];
+  for (const relPath of sortedPaths) {
+    await slicer.tick();
+    const built = buildFile(cwd, relPath, treeSitterExtractor, readFile);
+    if (built) builtFiles.push(built);
+  }
+  return codewikiFromBuiltFiles(cwd, language, builtFiles, slicer);
+}
+async function buildCodewiki(input, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const files = (await enumerateWorkspaceFilesAsync(input.cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer)).filter(
+    isIndexablePath
+  );
+  return buildFromPaths(input.cwd, input.language, files, { ...options, slicer });
+}
+async function updateCodewikiPaths(cwd, codewiki, paths, options = {}) {
+  const normalizedPaths = uniqueSorted2(
+    paths.map(normalizeInputPath).filter((path) => path.length > 0 && !path.startsWith(".."))
+  );
+  if (normalizedPaths.length === 0) return codewiki;
+  if (normalizedPaths.some(
+    (path) => path === ".gitignore" || path.endsWith("/.gitignore") || path === ".git/info/exclude" || path === ".git/index" || path === ".gitmodules"
+  )) {
+    return syncCodewiki(cwd, codewiki, options);
+  }
+  const slicer = options.slicer ?? createSlicer();
+  const existingFiles = new Map(codewiki.files.map((file) => [file.path, file]));
+  const visiblePaths = new Set(filterWorkspaceFileCandidates(cwd, normalizedPaths, WORKSPACE_EXCLUDED_DIRS));
+  const readFile = options.readFile ?? defaultReadFile;
+  const currentTexts = /* @__PURE__ */ new Map();
+  const changedPathSet = /* @__PURE__ */ new Set();
+  const rebuildPaths = [];
+  for (const relPath of normalizedPaths) {
+    const existing = existingFiles.get(relPath);
+    const isCurrentIndexableFile = isIndexablePath(relPath) && visiblePaths.has(relPath);
+    if (!existing && !isCurrentIndexableFile) continue;
+    if (isCurrentIndexableFile) {
+      const text = readFile(join2(cwd, relPath));
+      if (text !== null) {
+        if (existing?.hash === contentHash(text)) continue;
+        currentTexts.set(relPath, text);
+        rebuildPaths.push(relPath);
+      }
+    }
+    changedPathSet.add(relPath);
+  }
+  if (changedPathSet.size === 0) return codewiki;
+  const rebuiltFiles = [];
+  if (rebuildPaths.length > 0) {
+    const treeSitterExtractor = await loadTreeSitterExtractor();
+    await treeSitterExtractor.ensureGrammarsForPaths(rebuildPaths);
+    for (const relPath of rebuildPaths) {
+      await slicer.tick();
+      const built = buildFile(
+        cwd,
+        relPath,
+        treeSitterExtractor,
+        (path) => currentTexts.get(normalizeRel(cwd, path)) ?? null
+      );
+      if (built) rebuiltFiles.push(built);
+    }
+  }
+  const removedFileIds = new Set(codewiki.files.filter((file) => changedPathSet.has(file.path)).map((file) => file.id));
+  const symbolsByFileId = /* @__PURE__ */ new Map();
+  for (const symbol of codewiki.symbols) {
+    if (removedFileIds.has(symbol.fileId)) continue;
+    const symbols = symbolsByFileId.get(symbol.fileId) ?? [];
+    symbols.push(symbol);
+    symbolsByFileId.set(symbol.fileId, symbols);
+  }
+  const keptFiles = codewiki.files.filter((file) => !changedPathSet.has(file.path)).map((file) => ({ file, symbols: symbolsByFileId.get(file.id) ?? [] }));
+  return codewikiFromBuiltFiles(cwd, codewiki.language, [...keptFiles, ...rebuiltFiles], slicer);
+}
+async function syncCodewiki(cwd, codewiki, options = {}) {
+  const slicer = options.slicer ?? createSlicer();
+  const readFile = options.readFile ?? defaultReadFile;
+  const currentPaths = (await enumerateWorkspaceFilesAsync(cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer)).filter(
+    isIndexablePath
+  );
+  const currentFiles = /* @__PURE__ */ new Map();
+  const currentTexts = /* @__PURE__ */ new Map();
+  for (const relPath of currentPaths) {
+    await slicer.tick();
+    const text = readFile(join2(cwd, relPath));
+    if (text !== null) {
+      currentFiles.set(relPath, contentHash(text));
+      currentTexts.set(relPath, text);
+    }
+  }
+  const indexedFiles = new Map(codewiki.files.map((file) => [file.path, file]));
+  const changedPaths = /* @__PURE__ */ new Set();
+  for (const [relPath, hash] of currentFiles) {
+    if (indexedFiles.get(relPath)?.hash !== hash) changedPaths.add(relPath);
+  }
+  for (const relPath of indexedFiles.keys()) {
+    if (!currentFiles.has(relPath)) changedPaths.add(relPath);
+  }
+  if (changedPaths.size === 0) {
+    if (!codewiki.files.some((file) => file.lang === "python")) return codewiki;
+    const edges = await buildEdges(cwd, codewiki.files, slicer);
+    return JSON.stringify(edges) === JSON.stringify(codewiki.edges) ? codewiki : { ...codewiki, edges };
+  }
+  const syncOptions = {
+    ...options,
+    slicer,
+    readFile: (path) => currentTexts.get(normalizeRel(cwd, path)) ?? readFile(path)
+  };
+  return updateCodewikiPaths(cwd, codewiki, [...changedPaths], syncOptions);
+}
+function symbolSigFields(kind, sig) {
+  if (!CODEWIKI_SYMBOL_KINDS_WITH_SIG.has(kind)) return {};
+  const clean = sig?.trim().slice(0, 240);
+  return clean && clean.length > 0 ? { sig: clean } : {};
+}
+
+export {
+  computeFingerprint,
+  computeFingerprintAsync,
+  computeFingerprintCached,
+  isStale,
+  buildCodewiki,
+  updateCodewikiPaths,
+  syncCodewiki
+};
+//# sourceMappingURL=chunk-QG6I2T5E.js.map