scip-query 0.2.1 → 0.3.1

package/dist/chunk-AXQKUYKF.js

@@ -0,0 +1,1442 @@
+import {
+  isFunctionLikeSymbol,
+  isModuleLikeSymbol,
+  leafName,
+  leafSuffix,
+  parseSymbol,
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/source-analysis.ts
+import {
+  existsSync,
+  readFileSync
+} from "fs";
+import {
+  dirname,
+  extname,
+  join,
+  relative,
+  resolve
+} from "path";
+var SOURCE_IMPORT_CACHE = /* @__PURE__ */ new WeakMap();
+var SOURCE_TEXT_CACHE = /* @__PURE__ */ new WeakMap();
+var SOURCE_CALL_CACHE = /* @__PURE__ */ new WeakMap();
+var SOURCE_BINDING_CACHE = /* @__PURE__ */ new WeakMap();
+var INDEXED_PATH_CACHE = /* @__PURE__ */ new WeakMap();
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var PYTHON_SOURCE_EXTENSIONS = [".py", ".pyi"];
+function getSourceImports(db, relativePath) {
+  const cache = getCachedMap(SOURCE_IMPORT_CACHE, db);
+  const normalized = normalizePath(relativePath);
+  const cached = cache.get(normalized);
+  if (cached) {
+    return cached;
+  }
+  const fullPath = join(db.config.projectRoot, normalized);
+  if (!existsSync(fullPath)) {
+    cache.set(normalized, []);
+    return [];
+  }
+  const source = readFileSync(fullPath, "utf-8");
+  const parsed = isPythonSourcePath(normalized) ? parsePythonImports(db, normalized, source) : parseJavaScriptImports(db, normalized, source);
+  cache.set(normalized, parsed);
+  return parsed;
+}
+function getSourceCalls(db, relativePath, opts = {}) {
+  const normalized = normalizePath(relativePath);
+  if (!isPythonSourcePath(normalized) && !isJavaScriptSourcePath(normalized)) {
+    return [];
+  }
+  const cache = getCachedMap(SOURCE_CALL_CACHE, db);
+  const key = `${normalized}:${opts.startLine ?? 0}:${opts.endLine ?? Number.MAX_SAFE_INTEGER}`;
+  const cached = cache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const source = getSourceText(db, normalized);
+  if (!source) {
+    cache.set(key, []);
+    return [];
+  }
+  const lines = source.split("\n");
+  const startLine = Math.max(0, opts.startLine ?? 0);
+  const endLine = Math.min(lines.length - 1, opts.endLine ?? lines.length - 1);
+  const scopedLines = lines.slice(startLine, endLine + 1);
+  const calls = isPythonSourcePath(normalized) ? parsePythonCalls(scopedLines, startLine) : parseJavaScriptCalls(scopedLines, startLine);
+  cache.set(key, calls);
+  return calls;
+}
+function getSourceConstructorBindings(db, relativePath, opts = {}) {
+  const normalized = normalizePath(relativePath);
+  if (!isPythonSourcePath(normalized) && !isJavaScriptSourcePath(normalized)) {
+    return [];
+  }
+  const cache = getCachedMap(SOURCE_BINDING_CACHE, db);
+  const key = `${normalized}:${opts.startLine ?? 0}:${opts.endLine ?? Number.MAX_SAFE_INTEGER}`;
+  const cached = cache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const source = getSourceText(db, normalized);
+  if (!source) {
+    cache.set(key, []);
+    return [];
+  }
+  const lines = source.split("\n");
+  const startLine = Math.max(0, opts.startLine ?? 0);
+  const endLine = Math.min(lines.length - 1, opts.endLine ?? lines.length - 1);
+  const scopedLines = lines.slice(startLine, endLine + 1);
+  const bindings = isPythonSourcePath(normalized) ? parsePythonConstructorBindings(scopedLines) : parseJavaScriptConstructorBindings(scopedLines);
+  cache.set(key, bindings);
+  return bindings;
+}
+function findIdentifierLines(db, relativePath, identifier, opts = {}) {
+  if (!identifier) {
+    return [];
+  }
+  const source = getSourceText(db, normalizePath(relativePath));
+  if (!source) {
+    return [];
+  }
+  const lines = stripCommentsAndStrings(source).split("\n");
+  const regex = new RegExp(`\\b${escapeRegex(identifier)}\\b`);
+  const results = [];
+  for (let line = 0; line < lines.length; line++) {
+    if (typeof opts.excludeStartLine === "number" && typeof opts.excludeEndLine === "number" && line >= opts.excludeStartLine && line <= opts.excludeEndLine) {
+      continue;
+    }
+    if (regex.test(lines[line] ?? "")) {
+      results.push(line);
+    }
+  }
+  return results;
+}
+function parseJavaScriptImports(db, importerPath, source) {
+  return parseJavaScriptImportStatements(source).flatMap((statement) => parseJavaScriptImportStatement(
+    db,
+    importerPath,
+    statement.clause,
+    statement.specifier,
+    statement.start,
+    statement.end,
+    source
+  ));
+}
+function parseJavaScriptImportStatements(source) {
+  const statements = [];
+  const importFromRegex = /^[ \t]*import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]\s*;?/gm;
+  for (const match of source.matchAll(importFromRegex)) {
+    const full = match[0];
+    const clause = match[1];
+    const specifier = match[2];
+    if (!full || !specifier || typeof match.index !== "number") continue;
+    statements.push({
+      clause,
+      specifier,
+      start: match.index,
+      end: match.index + full.length
+    });
+  }
+  const sideEffectRegex = /^[ \t]*import\s+['"]([^'"]+)['"]\s*;?/gm;
+  for (const match of source.matchAll(sideEffectRegex)) {
+    const full = match[0];
+    const specifier = match[1];
+    if (!full || !specifier || typeof match.index !== "number") continue;
+    statements.push({
+      clause: null,
+      specifier,
+      start: match.index,
+      end: match.index + full.length
+    });
+  }
+  return statements.sort((a, b) => a.start - b.start);
+}
+function parseJavaScriptImportStatement(db, importerPath, clause, specifier, start, end, source) {
+  const resolvedSource = resolveImportPath(db, importerPath, specifier);
+  const body = buildUsageBody(source, start, end);
+  if (!clause) {
+    return [{
+      importedName: "*",
+      localName: null,
+      sourcePath: resolvedSource,
+      kind: "side-effect",
+      used: true,
+      usedMembers: []
+    }];
+  }
+  const bindings = parseImportClause(clause).map((binding) => ({
+    ...binding,
+    sourcePath: resolvedSource
+  }));
+  return bindings.map((binding) => {
+    if (binding.kind === "namespace") {
+      const usedMembers = collectNamespaceMembers(body, binding.localName);
+      return {
+        ...binding,
+        used: usedMembers.length > 0 || hasIdentifierUsage(body, binding.localName),
+        usedMembers
+      };
+    }
+    if (binding.kind === "side-effect") {
+      return { ...binding, used: true, usedMembers: [] };
+    }
+    return {
+      ...binding,
+      used: binding.localName ? hasIdentifierUsage(body, binding.localName) : false,
+      usedMembers: []
+    };
+  });
+}
+function parsePythonCalls(lines, baseLine) {
+  const calls = [];
+  const controlKeywords = /* @__PURE__ */ new Set([
+    "if",
+    "for",
+    "while",
+    "with",
+    "except",
+    "elif",
+    "return",
+    "yield",
+    "assert",
+    "raise",
+    "lambda",
+    "class",
+    "def"
+  ]);
+  for (let index = 0; index < lines.length; index++) {
+    const rawLine = lines[index] ?? "";
+    const stripped = stripCommentsAndStrings(rawLine);
+    if (!stripped.trim()) continue;
+    const attributeMatches = [...stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\.\s*([A-Za-z_][\w]*)\s*\(/g)];
+    const attributeRanges = attributeMatches.map((match) => ({
+      start: match.index ?? -1,
+      end: (match.index ?? -1) + match[0].length
+    }));
+    for (const match of attributeMatches) {
+      const receiverName = match[1];
+      const calleeName = match[2];
+      if (!receiverName || !calleeName) continue;
+      calls.push({
+        receiverName,
+        calleeName,
+        line: baseLine + index
+      });
+    }
+    for (const match of stripped.matchAll(/\b([A-Za-z_][\w]*)\s*\(/g)) {
+      const calleeName = match[1];
+      const start = match.index ?? -1;
+      if (!calleeName || start < 0) continue;
+      if (controlKeywords.has(calleeName)) continue;
+      if (attributeRanges.some((range) => start >= range.start && start < range.end)) continue;
+      const prefix = stripped.slice(0, start).trimEnd();
+      if (prefix.endsWith("def") || prefix.endsWith("class") || prefix.endsWith("async def")) {
+        continue;
+      }
+      calls.push({
+        receiverName: null,
+        calleeName,
+        line: baseLine + index
+      });
+    }
+  }
+  return calls;
+}
+function parseJavaScriptCalls(lines, baseLine) {
+  const calls = [];
+  const controlKeywords = /* @__PURE__ */ new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "function",
+    "class",
+    "return",
+    "typeof",
+    "import"
+  ]);
+  for (let index = 0; index < lines.length; index++) {
+    const stripped = stripCommentsAndStrings(lines[index] ?? "");
+    if (!stripped.trim()) continue;
+    const attributeMatches = [
+      ...stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g),
+      ...stripped.matchAll(/\bthis\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*\(/g)
+    ];
+    const attributeRanges = attributeMatches.map((match) => ({
+      start: match.index ?? -1,
+      end: (match.index ?? -1) + match[0].length
+    }));
+    for (const match of attributeMatches) {
+      const receiverName = match[2] ? match[1] : "this";
+      const calleeName = match[2] ?? match[1];
+      if (!receiverName || !calleeName) continue;
+      calls.push({
+        receiverName,
+        calleeName,
+        line: baseLine + index
+      });
+    }
+    for (const match of stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g)) {
+      const calleeName = match[1];
+      const start = match.index ?? -1;
+      if (!calleeName || start < 0) continue;
+      if (controlKeywords.has(calleeName)) continue;
+      if (attributeRanges.some((range) => start >= range.start && start < range.end)) continue;
+      const prefix = stripped.slice(0, start).trimEnd();
+      if (prefix.endsWith("function") || prefix.endsWith("class") || prefix.endsWith("new")) {
+        continue;
+      }
+      calls.push({
+        receiverName: null,
+        calleeName,
+        line: baseLine + index
+      });
+    }
+  }
+  return calls;
+}
+function parsePythonConstructorBindings(lines) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const rawLine of lines) {
+    const stripped = stripCommentsAndStrings(rawLine);
+    const constructorMatch = stripped.match(/\b([A-Za-z_][\w]*)\s*=\s*([A-Z][\w]*)\s*\(/);
+    if (constructorMatch?.[1] && constructorMatch[2]) {
+      bindings.set(constructorMatch[1], constructorMatch[2]);
+    }
+  }
+  return [...bindings.entries()].map(([localName, typeName]) => ({ localName, typeName }));
+}
+function parseJavaScriptConstructorBindings(lines) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const rawLine of lines) {
+    const stripped = stripCommentsAndStrings(rawLine);
+    for (const match of stripped.matchAll(/\b([A-Za-z_$][\w$]*)\s*:\s*([A-Z][A-Za-z0-9_$]*)\b/g)) {
+      const localName = match[1];
+      const typeName = match[2];
+      if (localName && typeName) {
+        bindings.set(localName, typeName);
+      }
+    }
+    const constructorMatch = stripped.match(/\b(?:const|let|var)?\s*([A-Za-z_$][\w$]*)\s*(?::\s*[A-Z][A-Za-z0-9_$<> ,]*)?\s*=\s*new\s+([A-Z][A-Za-z0-9_$]*)\s*\(/);
+    if (constructorMatch?.[1] && constructorMatch[2]) {
+      bindings.set(constructorMatch[1], constructorMatch[2]);
+    }
+  }
+  return [...bindings.entries()].map(([localName, typeName]) => ({ localName, typeName }));
+}
+function parsePythonImports(db, importerPath, source) {
+  return collectPythonImportStatements(source).flatMap(
+    (statement) => parsePythonImportStatement(db, importerPath, statement, source)
+  );
+}
+function collectPythonImportStatements(source) {
+  const lines = source.split("\n");
+  const statements = [];
+  let offset = 0;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    const trimmed = line.trimStart();
+    const lineStart = offset;
+    offset += line.length + 1;
+    if (!trimmed.startsWith("import ") && !trimmed.startsWith("from ")) {
+      continue;
+    }
+    let statement = line;
+    let statementEnd = lineStart + line.length;
+    let balance = pythonParenBalance(line);
+    while (lineIndex + 1 < lines.length && (balance > 0 || statement.trimEnd().endsWith("\\"))) {
+      lineIndex++;
+      const nextLine = lines[lineIndex];
+      statement += `
+${nextLine}`;
+      statementEnd += 1 + nextLine.length;
+      balance += pythonParenBalance(nextLine);
+      offset += nextLine.length + 1;
+    }
+    const parsed = parsePythonStatementHeader(statement);
+    if (parsed) {
+      statements.push({
+        ...parsed,
+        start: lineStart,
+        end: statementEnd
+      });
+    }
+  }
+  return statements;
+}
+function parsePythonStatementHeader(statement) {
+  const normalized = statement.replace(/\\\s*\n/g, " ").trim();
+  if (normalized.startsWith("import ")) {
+    return {
+      kind: "import",
+      module: null,
+      clause: normalized.slice("import ".length).trim()
+    };
+  }
+  const fromMatch = normalized.match(/^from\s+([.\w]+)\s+import\s+([\s\S]+)$/);
+  if (!fromMatch) {
+    return null;
+  }
+  let clause = fromMatch[2].trim();
+  if (clause.startsWith("(") && clause.endsWith(")")) {
+    clause = clause.slice(1, -1).trim();
+  }
+  return {
+    kind: "from",
+    module: fromMatch[1],
+    clause
+  };
+}
+function parsePythonImportStatement(db, importerPath, statement, source) {
+  const body = buildUsageBody(source, statement.start, statement.end);
+  const normalizedClause = statement.clause.replace(/\n/g, " ").trim();
+  if (statement.kind === "import") {
+    return splitTopLevel(normalizedClause).flatMap((entry) => {
+      const cleaned = entry.trim().replace(/,$/, "");
+      if (!cleaned) return [];
+      const [moduleName, alias] = cleaned.split(/\s+as\s+/);
+      const importedName = moduleName.trim();
+      const localName = (alias ?? importedName.split(".")[0] ?? importedName).trim();
+      const sourcePath2 = resolvePythonImportPath(db, importerPath, importedName);
+      const usedMembers = collectNamespaceMembers(body, localName);
+      return [{
+        importedName,
+        localName,
+        sourcePath: sourcePath2,
+        kind: "namespace",
+        used: hasIdentifierUsage(body, localName) || usedMembers.length > 0,
+        usedMembers
+      }];
+    });
+  }
+  const sourcePath = statement.module ? resolvePythonImportPath(db, importerPath, statement.module) : null;
+  const results = [];
+  for (const entry of splitTopLevel(normalizedClause)) {
+    const cleaned = entry.trim().replace(/,$/, "");
+    if (!cleaned) continue;
+    if (cleaned === "*") {
+      results.push({
+        importedName: "*",
+        localName: null,
+        sourcePath,
+        kind: "side-effect",
+        used: true,
+        usedMembers: []
+      });
+      continue;
+    }
+    const [importedName, alias] = cleaned.split(/\s+as\s+/);
+    const localName = (alias ?? importedName).trim();
+    results.push({
+      importedName: importedName.trim(),
+      localName,
+      sourcePath,
+      kind: "named",
+      used: hasIdentifierUsage(body, localName),
+      usedMembers: []
+    });
+  }
+  return results;
+}
+function parseImportClause(clause) {
+  const trimmed = clause.trim().replace(/^type\s+/, "");
+  const [first, second] = splitImportClause(trimmed);
+  const entries = [];
+  if (first) {
+    entries.push(...parseImportBinding(first));
+  }
+  if (second) {
+    entries.push(...parseImportBinding(second));
+  }
+  return entries;
+}
+function parseImportBinding(binding) {
+  const trimmed = binding.trim();
+  if (!trimmed) return [];
+  if (trimmed.startsWith("{")) {
+    const inner = trimmed.slice(1, -1).trim();
+    if (!inner) return [];
+    return splitTopLevel(inner).map((entry) => {
+      const cleaned = entry.trim().replace(/^type\s+/, "");
+      const [importedName, alias] = cleaned.split(/\s+as\s+/);
+      return {
+        importedName: importedName.trim(),
+        localName: (alias ?? importedName).trim(),
+        kind: "named"
+      };
+    });
+  }
+  if (trimmed.startsWith("* as ")) {
+    return [{
+      importedName: "*",
+      localName: trimmed.slice(5).trim(),
+      kind: "namespace"
+    }];
+  }
+  return [{
+    importedName: "default",
+    localName: trimmed,
+    kind: "default"
+  }];
+}
+function splitImportClause(clause) {
+  let depth = 0;
+  for (let i = 0; i < clause.length; i++) {
+    const char = clause[i];
+    if (char === "{") depth++;
+    if (char === "}") depth--;
+    if (char === "," && depth === 0) {
+      return [clause.slice(0, i).trim(), clause.slice(i + 1).trim()];
+    }
+  }
+  return [clause.trim(), null];
+}
+function splitTopLevel(input) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (char === "{" || char === "[" || char === "(") depth++;
+    if (char === "}" || char === "]" || char === ")") depth--;
+    if (char === "," && depth === 0) {
+      parts.push(input.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(input.slice(start));
+  return parts;
+}
+function buildUsageBody(source, start, end) {
+  const masked = `${source.slice(0, start)}${" ".repeat(end - start)}${source.slice(end)}`;
+  return stripCommentsAndStrings(masked);
+}
+function stripCommentsAndStrings(source) {
+  return source.replace(/'''[\s\S]*?'''/g, maskPreservingLines).replace(/"""[\s\S]*?"""/g, maskPreservingLines).replace(/#.*$/gm, maskPreservingLines).replace(/\/\/.*$/gm, maskPreservingLines).replace(/\/\*[\s\S]*?\*\//g, maskPreservingLines).replace(/`(?:\\[\s\S]|[^`])*`/g, maskPreservingLines).replace(/'(?:\\.|[^'\\\r\n])*'/g, maskPreservingLines).replace(/"(?:\\.|[^"\\\r\n])*"/g, maskPreservingLines);
+}
+function maskPreservingLines(segment) {
+  return segment.replace(/[^\r\n]/g, " ");
+}
+function hasIdentifierUsage(body, identifier) {
+  return new RegExp(`\\b${escapeRegex(identifier)}\\b`, "m").test(body);
+}
+function collectNamespaceMembers(body, namespaceName) {
+  const members = /* @__PURE__ */ new Set();
+  const regex = new RegExp(`\\b${escapeRegex(namespaceName)}\\s*\\.\\s*([A-Za-z_$][\\w$]*)`, "g");
+  for (const match of body.matchAll(regex)) {
+    const member = match[1];
+    if (member) {
+      members.add(member);
+    }
+  }
+  return [...members];
+}
+function resolveImportPath(db, importerPath, specifier) {
+  if (isPythonSourcePath(importerPath)) {
+    return resolvePythonImportPath(db, importerPath, specifier);
+  }
+  return resolveJavaScriptImportPath(db, importerPath, specifier);
+}
+function resolveJavaScriptImportPath(db, importerPath, specifier) {
+  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+    return null;
+  }
+  const importerDir = dirname(join(db.config.projectRoot, importerPath));
+  const absolute = resolve(importerDir, specifier);
+  const indexedPaths = getIndexedPaths(db);
+  for (const candidate of candidateImportPaths(absolute)) {
+    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return normalizePath(relative(db.config.projectRoot, absolute));
+}
+function resolvePythonImportPath(db, importerPath, specifier) {
+  const indexedPaths = getIndexedPaths(db);
+  let basePath;
+  if (specifier.startsWith(".")) {
+    const match = specifier.match(/^(\.+)(.*)$/);
+    if (!match) return null;
+    const dots = match[1].length;
+    const remainder = match[2].replace(/^\./, "");
+    let baseDir = dirname(join(db.config.projectRoot, importerPath));
+    for (let i = 1; i < dots; i++) {
+      baseDir = dirname(baseDir);
+    }
+    basePath = remainder ? resolve(baseDir, remainder.replace(/\./g, "/")) : baseDir;
+  } else {
+    basePath = resolve(db.config.projectRoot, specifier.replace(/\./g, "/"));
+  }
+  for (const candidate of pythonCandidateImportPaths(basePath)) {
+    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return null;
+}
+function pythonCandidateImportPaths(basePath) {
+  const ext = extname(basePath);
+  if (PYTHON_SOURCE_EXTENSIONS.includes(ext)) {
+    return [basePath];
+  }
+  return [
+    `${basePath}.py`,
+    `${basePath}.pyi`,
+    join(basePath, "__init__.py"),
+    join(basePath, "__init__.pyi")
+  ];
+}
+function candidateImportPaths(absolute) {
+  const ext = extname(absolute);
+  const candidates = /* @__PURE__ */ new Set();
+  if (ext) {
+    candidates.add(absolute);
+    for (const sourceExt of SOURCE_EXTENSIONS) {
+      candidates.add(absolute.slice(0, -ext.length) + sourceExt);
+    }
+  } else {
+    for (const sourceExt of SOURCE_EXTENSIONS) {
+      candidates.add(`${absolute}${sourceExt}`);
+      candidates.add(join(absolute, `index${sourceExt}`));
+    }
+  }
+  return [...candidates];
+}
+function getIndexedPaths(db) {
+  const cached = INDEXED_PATH_CACHE.get(db);
+  if (cached) {
+    return cached;
+  }
+  const paths = new Set(
+    db.all(
+      `SELECT relative_path
+       FROM documents
+       WHERE 1 = 1
+         ${db.pathExclusionsFor("documents")}`
+    ).map((row) => normalizePath(row.relative_path)).filter((relativePath) => !db.isIgnored(relativePath))
+  );
+  INDEXED_PATH_CACHE.set(db, paths);
+  return paths;
+}
+function getCachedMap(cache, db) {
+  let map = cache.get(db);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    cache.set(db, map);
+  }
+  return map;
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function isJavaScriptSourcePath(relativePath) {
+  return SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function isPythonSourcePath(relativePath) {
+  return PYTHON_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function getSourceText(db, relativePath) {
+  const cache = getCachedMap(SOURCE_TEXT_CACHE, db);
+  const normalized = normalizePath(relativePath);
+  const cached = cache.get(normalized);
+  if (typeof cached === "string") {
+    return cached;
+  }
+  const fullPath = join(db.config.projectRoot, normalized);
+  if (!existsSync(fullPath)) {
+    cache.set(normalized, "");
+    return "";
+  }
+  const source = readFileSync(fullPath, "utf-8");
+  cache.set(normalized, source);
+  return source;
+}
+function pythonParenBalance(value) {
+  let balance = 0;
+  for (const char of value) {
+    if (char === "(") balance++;
+    if (char === ")") balance--;
+  }
+  return balance;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/query-support.ts
+import { basename } from "path";
+var FILE_DEFINITION_CACHE = /* @__PURE__ */ new WeakMap();
+var TEST_FILE_PATTERNS = [
+  "%/__tests__/%",
+  "%.test.%",
+  "%.spec.%",
+  "%/test/%",
+  "%/tests/%",
+  "%_test.%",
+  "%_spec.%",
+  "%/test_%.%",
+  "%/spec_%.%"
+];
+var TEST_SUPPORT_PATH_PATTERNS = [
+  "%/test-utils/%"
+];
+function testFileExclusionSql(alias, extraPatterns = []) {
+  const patterns = uniquePatterns([...TEST_FILE_PATTERNS, ...extraPatterns]);
+  return patterns.map((pattern) => `${alias}.relative_path NOT LIKE '${pattern}'`).join("\n      AND ");
+}
+function buildFileDepGraph(db, scope) {
+  const scopeFilter = scope ? `AND d1.relative_path LIKE '%${scope}%'` : "";
+  const edges = db.all(
+    `SELECT DISTINCT
+      d1.relative_path AS from_file,
+      d2.relative_path AS to_file
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d1 ON c.document_id = d1.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents d2 ON der.document_id = d2.id
+    WHERE d1.id != d2.id
+      AND m.role != 1
+      ${db.pathExclusionsFor("d1", "d2")}
+      ${scopeFilter}`
+  );
+  const graph = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (db.isIgnored(edge.from_file) || db.isIgnored(edge.to_file)) continue;
+    if (!graph.has(edge.from_file)) graph.set(edge.from_file, /* @__PURE__ */ new Set());
+    graph.get(edge.from_file).add(edge.to_file);
+  }
+  return graph;
+}
+function findFirstSymbolMatch(db, symbolPattern) {
+  const fileLineMatch = symbolPattern.match(/^(.+):(\d+)-(\d+)$/);
+  if (fileLineMatch) {
+    const [, filePath, startStr, endStr] = fileLineMatch;
+    const row = db.get(
+      `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+      FROM global_symbols gs
+      JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+      JOIN documents d ON der.document_id = d.id
+      WHERE d.relative_path LIKE ?
+        AND der.start_line <= ? AND der.end_line >= ?
+        ${db.pathExclusionsFor("d")}
+      ORDER BY (der.end_line - der.start_line) ASC
+      LIMIT 1`,
+      `%${filePath}%`,
+      parseInt(startStr, 10),
+      parseInt(endStr, 10)
+    );
+    if (row && !db.isIgnored(row.relative_path)) {
+      return {
+        symbolId: row.id,
+        symbol: row.symbol,
+        documentId: row.document_id,
+        startLine: row.start_line,
+        endLine: row.end_line,
+        relativePath: row.relative_path
+      };
+    }
+  }
+  const cleaned = normalizeLookupPattern(symbolPattern);
+  const tokens = lookupTokens(symbolPattern);
+  const candidates = getSymbolLookupCandidates(db, tokens);
+  let best = null;
+  for (const row of candidates) {
+    if (db.isIgnored(row.relative_path)) continue;
+    const score = scoreSymbolCandidate(row, symbolPattern, cleaned, tokens);
+    if (score <= 0) continue;
+    if (!best || score > best.score) {
+      best = { row, score };
+    }
+  }
+  if (best) {
+    return {
+      symbolId: best.row.id,
+      symbol: best.row.symbol,
+      documentId: best.row.document_id,
+      startLine: best.row.start_line,
+      endLine: best.row.end_line,
+      relativePath: best.row.relative_path
+    };
+  }
+  return null;
+}
+function findExactSymbolMatch(db, symbol) {
+  const row = db.get(
+    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+     FROM global_symbols gs
+     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+     JOIN documents d ON der.document_id = d.id
+     WHERE gs.symbol = ?
+       ${db.pathExclusionsFor("d")}
+     ORDER BY d.relative_path, der.start_line
+     LIMIT 1`,
+    symbol
+  );
+  if (!row || db.isIgnored(row.relative_path)) {
+    return null;
+  }
+  return {
+    symbolId: row.id,
+    symbol: row.symbol,
+    documentId: row.document_id,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    relativePath: row.relative_path
+  };
+}
+function resolveIndexedFile(db, filePattern) {
+  return resolveDocumentCandidates(db, filePattern, { allowMultiple: false })[0]?.relativePath ?? null;
+}
+function resolveIndexedPaths(db, filePattern) {
+  return resolveDocumentCandidates(db, filePattern, { allowMultiple: true }).map((candidate) => candidate.relativePath);
+}
+function normalizeLookupPattern(symbolPattern) {
+  return symbolPattern.trim().replace(/\(\)$/, "").replace(/\(.*$/, "");
+}
+function lookupTokens(symbolPattern) {
+  const cleaned = normalizeLookupPattern(symbolPattern);
+  const tokens = cleaned.split(/[^A-Za-z0-9_]+/).map((token) => token.trim()).filter((token) => token.length > 0);
+  return tokens.length > 0 ? [...new Set(tokens)] : [cleaned];
+}
+function getSymbolLookupCandidates(db, tokens) {
+  const tokenClauses = tokens.map(
+    () => `(gs.symbol LIKE ? OR d.relative_path LIKE ? OR COALESCE(gs.display_name, '') LIKE ?)`
+  );
+  const params = tokens.flatMap((token) => {
+    const like = `%${token}%`;
+    return [like, like, like];
+  });
+  return db.all(
+    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path, gs.display_name
+     FROM global_symbols gs
+     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+     JOIN documents d ON der.document_id = d.id
+     WHERE ${tokenClauses.join("\n       AND ")}
+       ${db.pathExclusionsFor("d")}
+     LIMIT 200`,
+    ...params
+  );
+}
+function scoreSymbolCandidate(row, originalPattern, cleanedPattern, tokens) {
+  const original = originalPattern.toLowerCase();
+  const cleaned = cleanedPattern.toLowerCase();
+  const noParens = cleaned.replace(/\(\)$/, "");
+  const raw = row.symbol.toLowerCase();
+  const short = shortenSymbol(row.symbol).toLowerCase();
+  const leaf = leafName(row.symbol).toLowerCase();
+  const display = (row.display_name ?? "").toLowerCase();
+  const path = row.relative_path.toLowerCase();
+  const looksPathLike = /[/:.]/.test(cleanedPattern);
+  let score = 0;
+  if (raw === original || raw === cleaned) score += 1e3;
+  if (short === original || short === cleaned) score += 950;
+  if (path === original || path === cleaned) score += 925;
+  if (path.endsWith(`/${cleaned}`) || path.endsWith(`/${original}`)) score += 875;
+  if (display === noParens) score += 850;
+  if (leaf === noParens) score += 825;
+  if (`${leaf}()` === original || `${leaf}()` === cleaned) score += 820;
+  if (short.endsWith(`:${cleaned}`) || short.endsWith(`:${noParens}`) || short.endsWith(`:${noParens}()`)) score += 800;
+  if (raw.includes(cleaned)) score += 120;
+  if (short.includes(cleaned)) score += 140;
+  if (path.includes(cleaned)) score += 140;
+  if (display.includes(cleaned)) score += 110;
+  if (tokens.every((token) => {
+    const lower = token.toLowerCase();
+    return raw.includes(lower) || short.includes(lower) || path.includes(lower) || display.includes(lower);
+  })) {
+    score += 100 + tokens.length * 15;
+  }
+  if (isFunctionLikeSymbol(row.symbol) && leaf === noParens) {
+    score += 60;
+  }
+  if (!looksPathLike && isModuleLikeSymbol(row.symbol)) {
+    score -= 160;
+  }
+  score -= Math.min(50, Math.max(0, row.end_line - row.start_line));
+  return score;
+}
+function getCalleeRowsForSymbol(db, symbol, opts = {}) {
+  const rows = db.all(
+    `SELECT DISTINCT
+      callee_gs.symbol AS symbol,
+      callee_d.relative_path AS file,
+      c.id AS chunk_id
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN global_symbols callee_gs ON m.symbol_id = callee_gs.id
+    JOIN defn_enclosing_ranges callee_der ON callee_gs.id = callee_der.symbol_id
+    JOIN documents callee_d ON callee_der.document_id = callee_d.id
+    WHERE c.document_id = ?
+      AND c.start_line >= ?
+      AND c.end_line <= ?
+      AND m.role != 1
+      AND callee_gs.id != ?
+      ${db.symbolNoiseFor("callee_gs")}
+      ${db.pathExclusionsFor("callee_d")}
+    ORDER BY callee_d.relative_path
+    ${opts.limit ? "LIMIT ?" : ""}`,
+    ...calleeQueryParams(symbol, opts.limit)
+  );
+  const primary = rows.filter((row) => !db.isIgnored(row.file)).map((row) => ({
+    symbol: row.symbol,
+    file: row.file,
+    chunkId: row.chunk_id
+  }));
+  const sourceFallback = getSourceBackedCalleeRows(db, symbol, opts.limit);
+  if (sourceFallback.length === 0) {
+    return primary;
+  }
+  if (primary.length === 0) {
+    return applyLimit(sourceFallback, opts.limit);
+  }
+  const seen = new Set(primary.map((row) => `${row.symbol}|${row.file}`));
+  const merged = [...primary];
+  for (const row of sourceFallback) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(row);
+  }
+  return applyLimit(merged, opts.limit);
+}
+function getCallerRowsForSymbol(db, symbol, opts = {}) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match) {
+    return [];
+  }
+  const primary = db.all(
+    `SELECT DISTINCT caller_gs.symbol AS caller_symbol, caller_d.relative_path AS caller_file
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents ref_d ON c.document_id = ref_d.id
+    JOIN defn_enclosing_ranges caller_der
+      ON caller_der.document_id = ref_d.id
+      AND c.start_line >= caller_der.start_line
+      AND c.end_line <= caller_der.end_line
+    JOIN global_symbols caller_gs ON caller_der.symbol_id = caller_gs.id
+    JOIN documents caller_d ON caller_der.document_id = caller_d.id
+    WHERE m.symbol_id = ?
+      AND m.role != 1
+      AND caller_gs.id != ?
+      ${db.symbolNoiseFor("caller_gs")}
+      ${db.pathExclusionsFor("caller_d")}
+    ORDER BY caller_d.relative_path
+    ${opts.limit ? "LIMIT ?" : ""}`,
+    ...callerQueryParams(match, opts.limit)
+  ).filter((row) => !db.isIgnored(row.caller_file)).map((row) => ({
+    symbol: row.caller_symbol,
+    file: row.caller_file
+  }));
+  const sourceFallback = getPythonSourceCallerRows(db, match, opts.limit);
+  if (sourceFallback.length === 0) {
+    return primary;
+  }
+  const merged = sourceFallback.length > 0 ? [...sourceFallback] : [];
+  const seen = new Set(merged.map((row) => `${row.symbol}|${row.file}`));
+  for (const row of primary) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    if (isFunctionLikeSymbol(row.symbol) || merged.length === 0) {
+      seen.add(key);
+      merged.push(row);
+    }
+  }
+  return applyLimit(merged, opts.limit);
+}
+function getSourceReferenceSites(db, symbol) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match) {
+    return [];
+  }
+  const identifier = leafName(match.symbol);
+  if (!identifier || !hasUniqueLeafDefinition(db, identifier, match.symbolId)) {
+    return [];
+  }
+  const documents = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const sites = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const document of documents) {
+    if (db.isIgnored(document.relative_path)) continue;
+    const lines = findIdentifierLines(db, document.relative_path, identifier, document.relative_path === match.relativePath ? { excludeStartLine: match.startLine, excludeEndLine: match.endLine } : {});
+    for (const line of lines) {
+      const enclosing = db.get(
+        `SELECT gs.symbol
+         FROM defn_enclosing_ranges der
+         JOIN global_symbols gs ON der.symbol_id = gs.id
+         JOIN documents d ON der.document_id = d.id
+         WHERE d.relative_path = ?
+           AND der.start_line <= ?
+           AND der.end_line >= ?
+         ORDER BY (der.end_line - der.start_line) ASC
+         LIMIT 1`,
+        document.relative_path,
+        line,
+        line
+      );
+      const key = `${document.relative_path}|${line}|${enclosing?.symbol ?? ""}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      sites.push({
+        file: document.relative_path,
+        line,
+        enclosingSymbol: enclosing?.symbol ?? null
+      });
+    }
+  }
+  return sites;
+}
+function calleeQueryParams(symbol, limit) {
+  const params = [
+    symbol.documentId,
+    symbol.startLine,
+    symbol.endLine,
+    symbol.symbolId
+  ];
+  if (typeof limit === "number") {
+    params.push(limit);
+  }
+  return params;
+}
+function callerQueryParams(symbol, limit) {
+  const params = [symbol.symbolId, symbol.symbolId];
+  if (typeof limit === "number") {
+    params.push(limit);
+  }
+  return params;
+}
+function getPythonSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isPythonDocument(db, match.relativePath)) {
+    return [];
+  }
+  const definitions = getDefinitionsForFile(db, match.relativePath);
+  const current = definitions.find((definition) => definition.symbolId === match.symbolId);
+  if (!current) {
+    return [];
+  }
+  const imports = getSourceImports(db, match.relativePath);
+  const bindings = new Map(
+    getSourceConstructorBindings(db, match.relativePath, {
+      startLine: match.startLine,
+      endLine: match.endLine
+    }).map((binding) => [binding.localName, binding.typeName])
+  );
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const call of getSourceCalls(db, match.relativePath, {
+    startLine: match.startLine,
+    endLine: match.endLine
+  })) {
+    const resolved = resolvePythonCallTarget(
+      db,
+      current,
+      definitions,
+      imports,
+      bindings,
+      call.receiverName,
+      call.calleeName
+    );
+    if (!resolved || resolved.symbolId === match.symbolId || db.isIgnored(resolved.relativePath)) continue;
+    const chunkId = 1e9 + call.line;
+    const key = `${resolved.symbol}|${resolved.relativePath}|${chunkId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    rows.push({
+      symbol: resolved.symbol,
+      file: resolved.relativePath,
+      chunkId
+    });
+  }
+  return applyLimit(rows, limit);
+}
+function getJavaScriptSourceCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match || !isJavaScriptDocument(db, match.relativePath)) {
+    return [];
+  }
+  const definitions = getDefinitionsForFile(db, match.relativePath);
+  const current = definitions.find((definition) => definition.symbolId === match.symbolId);
+  if (!current) {
+    return [];
+  }
+  const imports = getSourceImports(db, match.relativePath);
+  const bindings = new Map(
+    getSourceConstructorBindings(db, match.relativePath, {
+      startLine: match.startLine,
+      endLine: match.endLine
+    }).map((binding) => [binding.localName, binding.typeName])
+  );
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const call of getSourceCalls(db, match.relativePath, {
+    startLine: match.startLine,
+    endLine: match.endLine
+  })) {
+    const resolved = resolveJavaScriptCallTarget(
+      db,
+      current,
+      definitions,
+      imports,
+      bindings,
+      call.receiverName,
+      call.calleeName
+    );
+    if (!resolved || resolved.symbolId === match.symbolId || db.isIgnored(resolved.relativePath)) continue;
+    const chunkId = 1e9 + call.line;
+    const key = `${resolved.symbol}|${resolved.relativePath}|${chunkId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    rows.push({
+      symbol: resolved.symbol,
+      file: resolved.relativePath,
+      chunkId
+    });
+  }
+  return applyLimit(rows, limit);
+}
+function getSourceBackedCalleeRows(db, symbol, limit) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match) {
+    return [];
+  }
+  if (isPythonDocument(db, match.relativePath)) {
+    return getPythonSourceCalleeRows(db, match, limit);
+  }
+  if (isJavaScriptDocument(db, match.relativePath)) {
+    return getJavaScriptSourceCalleeRows(db, match, limit);
+  }
+  return [];
+}
+function getPythonSourceCallerRows(db, target, limit) {
+  if (!isPythonDocument(db, target.relativePath)) {
+    return [];
+  }
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of getAllFunctionLikeDefinitions(db)) {
+    if (candidate.symbolId === target.symbolId) continue;
+    const callees = getPythonSourceCalleeRows(db, candidate);
+    if (!callees.some((callee) => callee.symbol === target.symbol)) continue;
+    const key = `${candidate.symbol}|${candidate.relativePath}`;
+    if (seen.has(key) || db.isIgnored(candidate.relativePath)) continue;
+    seen.add(key);
+    rows.push({
+      symbol: candidate.symbol,
+      file: candidate.relativePath
+    });
+    if (typeof limit === "number" && rows.length >= limit) {
+      break;
+    }
+  }
+  return rows;
+}
+function getFullSymbolMatch(db, symbol) {
+  if ("symbol" in symbol && "relativePath" in symbol) {
+    return symbol;
+  }
+  const row = db.get(
+    `SELECT gs.symbol, d.relative_path
+     FROM global_symbols gs
+     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+     JOIN documents d ON der.document_id = d.id
+     WHERE gs.id = ?
+     LIMIT 1`,
+    symbol.symbolId
+  );
+  if (!row) {
+    return null;
+  }
+  return {
+    ...symbol,
+    symbol: row.symbol,
+    relativePath: row.relative_path
+  };
+}
+function getDefinitionsForFile(db, relativePath) {
+  let cache = FILE_DEFINITION_CACHE.get(db);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    FILE_DEFINITION_CACHE.set(db, cache);
+  }
+  const cached = cache.get(relativePath);
+  if (cached) {
+    return cached;
+  }
+  const definitions = db.all(
+    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+     FROM global_symbols gs
+     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+     JOIN documents d ON der.document_id = d.id
+     WHERE d.relative_path = ?
+       ${db.symbolNoiseFor("gs")}
+     ORDER BY der.start_line, der.end_line`,
+    relativePath
+  ).map((row) => ({
+    symbolId: row.id,
+    symbol: row.symbol,
+    documentId: row.document_id,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    relativePath: row.relative_path,
+    leaf: leafName(row.symbol),
+    parentTypeName: parentTypeName(row.symbol),
+    isFunctionLike: isFunctionLikeSymbol(row.symbol),
+    isTypeLike: leafSuffix(row.symbol) === "type"
+  }));
+  cache.set(relativePath, definitions);
+  return definitions;
+}
+function getAllFunctionLikeDefinitions(db) {
+  const rows = db.all(
+    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
+     FROM global_symbols gs
+     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+     JOIN documents d ON der.document_id = d.id
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("d")}
+       ${db.symbolNoiseFor("gs")}
+     ORDER BY d.relative_path, der.start_line`
+  );
+  return rows.filter((row) => !db.isIgnored(row.relative_path)).filter((row) => isFunctionLikeSymbol(row.symbol)).map((row) => ({
+    symbolId: row.id,
+    symbol: row.symbol,
+    documentId: row.document_id,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    relativePath: row.relative_path,
+    leaf: leafName(row.symbol),
+    parentTypeName: parentTypeName(row.symbol),
+    isFunctionLike: true,
+    isTypeLike: false
+  }));
+}
+function resolvePythonCallTarget(db, current, currentFileDefinitions, imports, constructorBindings, receiverName, calleeName) {
+  if (receiverName === "self" || receiverName === "cls") {
+    return findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
+  }
+  if (receiverName) {
+    const inferredType = constructorBindings.get(receiverName);
+    if (inferredType) {
+      const boundMethod = findDefinitionByName(currentFileDefinitions, calleeName, inferredType, ["function"]);
+      if (boundMethod) {
+        return boundMethod;
+      }
+      for (const entry of imports) {
+        if (entry.localName !== inferredType || !entry.sourcePath) continue;
+        const importedDefinitions = getDefinitionsForFile(db, entry.sourcePath);
+        const importedMethod = findDefinitionByName(importedDefinitions, calleeName, entry.importedName, ["function"]);
+        if (importedMethod) {
+          return importedMethod;
+        }
+      }
+    }
+    const localClassMethod = findDefinitionByName(currentFileDefinitions, calleeName, receiverName, ["function"]);
+    if (localClassMethod) {
+      return localClassMethod;
+    }
+    const namespaceImport = imports.find((entry) => entry.localName === receiverName && entry.sourcePath);
+    if (namespaceImport?.sourcePath) {
+      const importedDefinitions = getDefinitionsForFile(db, namespaceImport.sourcePath);
+      const importedTypeMethod = namespaceImport.kind === "named" ? findDefinitionByName(importedDefinitions, calleeName, namespaceImport.importedName, ["function"]) : null;
+      if (importedTypeMethod) {
+        return importedTypeMethod;
+      }
+      return findDefinitionByName(importedDefinitions, calleeName, null, ["function", "type"]);
+    }
+    return null;
+  }
+  const importedBinding = imports.find((entry) => entry.localName === calleeName && entry.sourcePath);
+  if (importedBinding?.sourcePath) {
+    const importedDefinitions = getDefinitionsForFile(db, importedBinding.sourcePath);
+    const importedName = importedBinding.importedName === "*" ? calleeName : importedBinding.importedName;
+    const importedDefinition = findDefinitionByName(importedDefinitions, importedName, null, ["function", "type"]);
+    if (importedDefinition) {
+      return importedDefinition;
+    }
+  }
+  return findDefinitionByName(currentFileDefinitions, calleeName, null, ["function", "type"]);
+}
+function resolveJavaScriptCallTarget(db, current, currentFileDefinitions, imports, constructorBindings, receiverName, calleeName) {
+  if (receiverName === "this") {
+    return findDefinitionByName(currentFileDefinitions, calleeName, current.parentTypeName, ["function"]);
+  }
+  if (receiverName) {
+    const inferredType = constructorBindings.get(receiverName);
+    if (inferredType) {
+      const boundMethod = findDefinitionByName(currentFileDefinitions, calleeName, inferredType, ["function"]);
+      if (boundMethod) {
+        return boundMethod;
+      }
+      for (const entry of imports) {
+        if (entry.localName !== inferredType || !entry.sourcePath) continue;
+        const importedDefinitions = getDefinitionsForFile(db, entry.sourcePath);
+        const importedMethod = findDefinitionByName(importedDefinitions, calleeName, entry.importedName, ["function"]);
+        if (importedMethod) {
+          return importedMethod;
+        }
+      }
+    }
+    const localClassMethod = findDefinitionByName(currentFileDefinitions, calleeName, receiverName, ["function"]);
+    if (localClassMethod) {
+      return localClassMethod;
+    }
+    const namespaceImport = imports.find((entry) => entry.localName === receiverName && entry.sourcePath);
+    if (namespaceImport?.sourcePath) {
+      const importedDefinitions = getDefinitionsForFile(db, namespaceImport.sourcePath);
+      if (namespaceImport.kind === "named" || namespaceImport.kind === "default") {
+        const importedTypeMethod = findDefinitionByName(
+          importedDefinitions,
+          calleeName,
+          namespaceImport.importedName,
+          ["function"]
+        );
+        if (importedTypeMethod) {
+          return importedTypeMethod;
+        }
+      }
+      return findDefinitionByName(importedDefinitions, calleeName, null, ["function", "type"]);
+    }
+    return null;
+  }
+  const importedBinding = imports.find((entry) => entry.localName === calleeName && entry.sourcePath && entry.kind !== "namespace");
+  if (importedBinding?.sourcePath) {
+    const importedDefinitions = getDefinitionsForFile(db, importedBinding.sourcePath);
+    const importedName = importedBinding.importedName === "default" ? importedBinding.localName ?? calleeName : importedBinding.importedName;
+    const importedDefinition = findDefinitionByName(importedDefinitions, importedName, null, ["function", "type"]);
+    if (importedDefinition) {
+      return importedDefinition;
+    }
+  }
+  return findDefinitionByName(currentFileDefinitions, calleeName, null, ["function", "type"]);
+}
+function findDefinitionByName(definitions, leaf, parentType, preference) {
+  const candidates = definitions.filter((definition) => definition.leaf === leaf && definition.parentTypeName === parentType);
+  if (candidates.length === 0) {
+    return null;
+  }
+  for (const preferred of preference) {
+    const match = candidates.find((candidate) => preferred === "function" ? candidate.isFunctionLike : candidate.isTypeLike);
+    if (match) {
+      return match;
+    }
+  }
+  return candidates[0] ?? null;
+}
+function hasUniqueLeafDefinition(db, leaf, symbolId) {
+  const rows = db.all(
+    `SELECT id, symbol
+     FROM global_symbols
+     WHERE symbol LIKE ?
+     LIMIT 50`,
+    `%${leaf}%`
+  );
+  let count = 0;
+  for (const row of rows) {
+    if (leafName(row.symbol) !== leaf) continue;
+    count++;
+    if (count > 1 && row.id !== symbolId) {
+      return false;
+    }
+  }
+  return count === 1;
+}
+function parentTypeName(rawSymbol) {
+  const parsed = parseSymbol(rawSymbol);
+  if ("kind" in parsed) {
+    return null;
+  }
+  for (let index = parsed.descriptors.length - 2; index >= 0; index--) {
+    const descriptor = parsed.descriptors[index];
+    if (descriptor?.suffix === "type") {
+      return descriptor.name;
+    }
+  }
+  return null;
+}
+function isPythonDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "python" || relativePath.endsWith(".py") || relativePath.endsWith(".pyi");
+}
+function isJavaScriptDocument(db, relativePath) {
+  const row = db.get(
+    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
+    relativePath
+  );
+  return row?.language === "typescript" || row?.language === "javascript" || /\.(?:[cm]?[jt]sx?)$/.test(relativePath);
+}
+function applyLimit(values, limit) {
+  return typeof limit === "number" ? values.slice(0, limit) : values;
+}
+function resolveDocumentCandidates(db, filePattern, opts) {
+  const normalizedPattern = normalizeLookupPath(filePattern);
+  if (!normalizedPattern) {
+    return [];
+  }
+  const rows = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const scored = rows.filter((row) => !db.isIgnored(row.relative_path)).map((row) => ({
+    relativePath: row.relative_path,
+    score: scoreDocumentPath(row.relative_path, normalizedPattern)
+  })).filter((row) => row.score > 0).sort((a, b) => b.score - a.score || a.relativePath.localeCompare(b.relativePath));
+  if (scored.length === 0) {
+    return [];
+  }
+  const exactish = scored.filter((row) => row.score >= 800);
+  if (exactish.length > 0) {
+    return opts.allowMultiple ? exactish : [exactish[0]];
+  }
+  return opts.allowMultiple ? scored : [scored[0]];
+}
+function scoreDocumentPath(relativePath, rawPattern) {
+  const normalizedPath = normalizeLookupPath(relativePath);
+  const pathBase = basename(normalizedPath);
+  const patternBase = basename(rawPattern);
+  let score = 0;
+  if (normalizedPath === rawPattern) score += 1200;
+  if (normalizedPath.endsWith(`/${rawPattern}`)) score += 1100;
+  if (pathBase === patternBase) score += 900;
+  if (normalizedPath.startsWith(`${rawPattern}/`)) score += 850;
+  if (normalizedPath.includes(rawPattern)) score += 250;
+  return score;
+}
+function normalizeLookupPath(filePattern) {
+  return filePattern.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function uniquePatterns(patterns) {
+  return [...new Set(patterns)];
+}
+
+export {
+  getSourceImports,
+  TEST_SUPPORT_PATH_PATTERNS,
+  testFileExclusionSql,
+  buildFileDepGraph,
+  findFirstSymbolMatch,
+  findExactSymbolMatch,
+  resolveIndexedFile,
+  resolveIndexedPaths,
+  getCalleeRowsForSymbol,
+  getCallerRowsForSymbol,
+  getSourceReferenceSites
+};
+//# sourceMappingURL=chunk-AXQKUYKF.js.map