scip-query 0.4.3 → 0.6.0

package/dist/chunk-VJMTX3OR.js

@@ -1,115 +0,0 @@
-import {
-  findFirstSymbolMatch,
-  getSourceReferenceSites,
-  getSourceText
-} from "./chunk-FMAYH7GS.js";
-import {
-  isFunctionLikeSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/refs.ts
-function refs(db, symbolPattern) {
-  const match = findFirstSymbolMatch(db, symbolPattern);
-  if (match) {
-    const includeDefinitionSite = !isFunctionLikeSymbol(match.symbol);
-    const definitionRows = includeDefinitionSite ? [{
-      relativePath: match.relativePath,
-      line: match.startLine
-    }] : [];
-    const sourceSites = getSourceReferenceSites(db, match).filter((site) => !db.isIgnored(site.file)).map((site) => ({
-      relativePath: site.file,
-      line: site.line
-    }));
-    if (sourceSites.length > 0) {
-      const seen2 = /* @__PURE__ */ new Set();
-      const rows2 = [...definitionRows, ...sourceSites, ...getRubySemanticRefs(db, match)].filter((site) => {
-        const key = `${site.relativePath}:${site.line}`;
-        if (seen2.has(key)) return false;
-        seen2.add(key);
-        return true;
-      });
-      return rows2;
-    }
-  }
-  const rows = db.all(
-    `SELECT DISTINCT d.relative_path, c.start_line
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d ON c.document_id = d.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    WHERE m.symbol_id = ?
-      AND ${db.localSymbolPredicate}
-      AND m.role != 1
-    ORDER BY d.relative_path, c.start_line`,
-    match?.symbolId ?? -1
-  );
-  const referenceRows = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    relativePath: r.relative_path,
-    line: r.start_line
-  }));
-  if (!match || db.isIgnored(match.relativePath) || isFunctionLikeSymbol(match.symbol)) {
-    return referenceRows;
-  }
-  const seen = new Set(referenceRows.map((row) => `${row.relativePath}:${row.line}`));
-  if (!seen.has(`${match.relativePath}:${match.startLine}`)) {
-    referenceRows.unshift({
-      relativePath: match.relativePath,
-      line: match.startLine
-    });
-  }
-  for (const row of getRubySemanticRefs(db, match)) {
-    const key = `${row.relativePath}:${row.line}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    referenceRows.push(row);
-  }
-  return referenceRows;
-}
-function getRubySemanticRefs(db, match) {
-  if (!match.relativePath.endsWith(".rb")) {
-    return [];
-  }
-  const tokens = rubyReferenceTokens(match.symbol);
-  if (tokens.length === 0) {
-    return [];
-  }
-  const rows = db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE relative_path LIKE '%.rb'
-       ${db.pathExclusionsFor("documents")}
-     ORDER BY relative_path`
-  );
-  const results = [];
-  for (const row of rows) {
-    if (db.isIgnored(row.relative_path)) continue;
-    const source = getSourceText(db, row.relative_path);
-    if (!source) continue;
-    const lines = source.split("\n");
-    for (let index = 0; index < lines.length; index++) {
-      const line = lines[index] ?? "";
-      if (tokens.some((token) => new RegExp(`@${token}\\b|\\b${token}:`).test(line))) {
-        results.push({
-          relativePath: row.relative_path,
-          line: index
-        });
-      }
-    }
-  }
-  return results;
-}
-function rubyReferenceTokens(rawSymbol) {
-  const leaf = rawSymbol.split(":").pop() ?? rawSymbol;
-  const snake = leaf.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9_]+/g, "_").toLowerCase().replace(/^_+|_+$/g, "");
-  const parts = snake.split("_").filter(Boolean);
-  const candidates = /* @__PURE__ */ new Set();
-  if (snake) candidates.add(snake);
-  if (parts.length >= 1) candidates.add(parts[parts.length - 1]);
-  if (parts.length >= 2) candidates.add(parts.slice(-2).join("_"));
-  return [...candidates];
-}
-
-export {
-  refs
-};
-//# sourceMappingURL=chunk-VJMTX3OR.js.map

package/dist/chunk-XJSPWHNT.js

@@ -1,64 +0,0 @@
-import {
-  getScopedDefinitions
-} from "./chunk-FMAYH7GS.js";
-import {
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/stale-abstractions.ts
-function staleAbstractions(db, opts) {
-  const { scope, minLoc = 3, limit = 30 } = opts ?? {};
-  const rows = getScopedDefinitions(db, scope).filter((definition) => definition.isTypeLike && definitionLoc(definition) >= minLoc).map((definition) => ({
-    symbol: definition.symbol,
-    file: definition.relativePath,
-    start_line: definition.startLine,
-    end_line: definition.endLine,
-    loc: definitionLoc(definition),
-    consumers: countCrossFileConsumers(db, definition)
-  })).filter((row) => row.consumers <= 1).sort((left, right) => right.loc - left.loc || left.file.localeCompare(right.file) || left.start_line - right.start_line);
-  const filesWithFunctions = getFilesWithFunctions(db, scope);
-  return rows.filter((r) => !db.isIgnored(r.file)).filter((r) => isTrueStaleAbstraction(r, filesWithFunctions)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    file: r.file,
-    startLine: r.start_line,
-    endLine: r.end_line,
-    loc: r.loc,
-    consumers: r.consumers
-  })).slice(0, limit);
-}
-function getFilesWithFunctions(db, scope) {
-  return new Set(getScopedDefinitions(db, scope).filter((definition) => definition.isFunctionLike).map((definition) => definition.relativePath));
-}
-function isTrueStaleAbstraction(row, filesWithFunctions) {
-  const basename = row.file.split("/").pop() ?? "";
-  const isTypeFile = basename.includes("types") || row.file.includes("/types/");
-  if (isTypeFile && row.consumers > 0) {
-    return false;
-  }
-  if (row.consumers === 0 && filesWithFunctions.has(row.file)) {
-    return false;
-  }
-  return true;
-}
-function countCrossFileConsumers(db, definition) {
-  const callers = db.all(
-    `SELECT DISTINCT d.relative_path
-     FROM mentions m
-     JOIN chunks c ON m.chunk_id = c.id
-     JOIN documents d ON c.document_id = d.id
-     WHERE m.symbol_id = ?
-       AND m.role != 1
-       ${db.pathExclusionsFor("d")}`,
-    definition.symbolId
-  ).map((row) => row.relative_path).filter((relativePath) => relativePath !== definition.relativePath && !db.isIgnored(relativePath));
-  return new Set(callers).size;
-}
-function definitionLoc(definition) {
-  return definition.endLine - definition.startLine + 1;
-}
-
-export {
-  staleAbstractions
-};
-//# sourceMappingURL=chunk-XJSPWHNT.js.map

package/dist/chunk-XMZAC2VU.js

@@ -1,84 +0,0 @@
-import {
-  resolveIndexedFile
-} from "./chunk-FMAYH7GS.js";
-
-// src/queries/coupling.ts
-function coupling(db, file1, file2) {
-  const resolvedFile1 = resolveIndexedFile(db, file1) ?? file1;
-  const resolvedFile2 = resolveIndexedFile(db, file2) ?? file2;
-  const row = db.get(
-    `SELECT COUNT(DISTINCT gs.id) AS shared
-    FROM global_symbols gs
-    WHERE (
-      -- Defined in file1, referenced in file2
-      EXISTS (
-        SELECT 1 FROM defn_enclosing_ranges der
-        JOIN documents d ON der.document_id = d.id
-        WHERE der.symbol_id = gs.id AND d.relative_path = ?
-      )
-      AND EXISTS (
-        SELECT 1 FROM mentions m
-        JOIN chunks c ON m.chunk_id = c.id
-        JOIN documents d ON c.document_id = d.id
-        WHERE m.symbol_id = gs.id AND m.role != 1 AND d.relative_path = ?
-      )
-    ) OR (
-      -- Defined in file2, referenced in file1
-      EXISTS (
-        SELECT 1 FROM defn_enclosing_ranges der
-        JOIN documents d ON der.document_id = d.id
-        WHERE der.symbol_id = gs.id AND d.relative_path = ?
-      )
-      AND EXISTS (
-        SELECT 1 FROM mentions m
-        JOIN chunks c ON m.chunk_id = c.id
-        JOIN documents d ON c.document_id = d.id
-        WHERE m.symbol_id = gs.id AND m.role != 1 AND d.relative_path = ?
-      )
-    )`,
-    resolvedFile1,
-    resolvedFile2,
-    resolvedFile2,
-    resolvedFile1
-  );
-  return {
-    file1: resolvedFile1,
-    file2: resolvedFile2,
-    sharedSymbols: row?.shared ?? 0
-  };
-}
-function topCoupling(db, opts = {}) {
-  const { limit = 20, scope } = opts;
-  const scopeFilter = scope ? `AND d1.relative_path LIKE '%${scope}%' AND d2.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT
-      def_d.relative_path AS file1,
-      ref_d.relative_path AS file2,
-      COUNT(DISTINCT gs.id) AS shared
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents ref_d ON c.document_id = ref_d.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents def_d ON der.document_id = def_d.id
-    WHERE m.role != 1
-      AND def_d.id != ref_d.id
-      ${db.pathExclusionsFor("def_d", "ref_d")}
-      ${scopeFilter}
-    GROUP BY def_d.id, ref_d.id
-    ORDER BY shared DESC
-    LIMIT ?`,
-    limit
-  );
-  return rows.filter((r) => !db.isIgnored(r.file1) && !db.isIgnored(r.file2)).map((r) => ({
-    file1: r.file1,
-    file2: r.file2,
-    sharedSymbols: r.shared
-  }));
-}
-
-export {
-  coupling,
-  topCoupling
-};
-//# sourceMappingURL=chunk-XMZAC2VU.js.map

package/dist/chunk-Y7FKURZG.js

@@ -1,130 +0,0 @@
-import {
-  getAllDefinitions,
-  getCalleeRowsForSymbol,
-  getCallerRowsForSymbol,
-  testFileExclusionSql
-} from "./chunk-FMAYH7GS.js";
-import {
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/complexity-hotspots.ts
-function complexityHotspots(db, opts) {
-  const { scope, minLoc = 10, limit = 30 } = opts ?? {};
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT
-      gs.symbol,
-      d.relative_path AS file,
-      der.start_line,
-      der.end_line,
-      (der.end_line - der.start_line + 1) AS loc,
-      -- fanIn: distinct files that reference this symbol
-      (SELECT COUNT(DISTINCT ref_c.document_id)
-       FROM mentions ref_m
-       JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-       WHERE ref_m.symbol_id = gs.id AND ref_m.role != 1
-      ) AS fan_in,
-      -- fanOut: distinct symbols referenced within this definition range
-      -- that are defined in different files
-      (SELECT COUNT(DISTINCT out_gs.id)
-       FROM mentions out_m
-       JOIN chunks out_c ON out_m.chunk_id = out_c.id
-       JOIN global_symbols out_gs ON out_m.symbol_id = out_gs.id
-       JOIN defn_enclosing_ranges out_der ON out_gs.id = out_der.symbol_id
-       WHERE out_c.document_id = der.document_id
-         AND out_c.start_line >= der.start_line
-         AND out_c.end_line <= der.end_line
-         AND out_m.role != 1
-         AND out_gs.id != gs.id
-         AND out_der.document_id != der.document_id
-      ) AS fan_out,
-      -- calleeCount: total distinct callees within definition range
-      (SELECT COUNT(DISTINCT callee_gs.id)
-       FROM mentions callee_m
-       JOIN chunks callee_c ON callee_m.chunk_id = callee_c.id
-       JOIN global_symbols callee_gs ON callee_m.symbol_id = callee_gs.id
-       WHERE callee_c.document_id = der.document_id
-         AND callee_c.start_line >= der.start_line
-         AND callee_c.end_line <= der.end_line
-         AND callee_m.role != 1
-         AND callee_gs.id != gs.id
-      ) AS callee_count
-    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")}
-      AND ${testFileExclusionSql("d")}
-      ${db.symbolNoiseFor("gs")}
-      AND (der.end_line - der.start_line + 1) >= ?
-      ${scopeFilter}
-    ORDER BY (
-      CAST((der.end_line - der.start_line + 1) AS REAL) / 50.0
-      * CAST((SELECT COUNT(DISTINCT ref_c2.document_id)
-              FROM mentions ref_m2
-              JOIN chunks ref_c2 ON ref_m2.chunk_id = ref_c2.id
-              WHERE ref_m2.symbol_id = gs.id AND ref_m2.role != 1
-             ) AS REAL) / 5.0
-      * MAX(CAST((SELECT COUNT(DISTINCT out_gs2.id)
-                  FROM mentions out_m2
-                  JOIN chunks out_c2 ON out_m2.chunk_id = out_c2.id
-                  JOIN global_symbols out_gs2 ON out_m2.symbol_id = out_gs2.id
-                  JOIN defn_enclosing_ranges out_der2 ON out_gs2.id = out_der2.symbol_id
-                  WHERE out_c2.document_id = der.document_id
-                    AND out_c2.start_line >= der.start_line
-                    AND out_c2.end_line <= der.end_line
-                    AND out_m2.role != 1
-                    AND out_gs2.id != gs.id
-                    AND out_der2.document_id != der.document_id
-                 ) AS REAL) / 5.0, 1.0)
-    ) DESC
-    LIMIT ?`,
-    minLoc,
-    limit
-  );
-  const indexedResults = rows.filter((r) => !db.isIgnored(r.file)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    file: r.file,
-    startLine: r.start_line,
-    endLine: r.end_line,
-    loc: r.loc,
-    fanIn: r.fan_in,
-    fanOut: r.fan_out,
-    calleeCount: r.callee_count,
-    score: Math.round(
-      r.loc / 50 * (r.fan_in / 5) * Math.max(r.fan_out / 5, 1) * 100
-    ) / 100
-  }));
-  if (indexedResults.length > 0) {
-    return indexedResults;
-  }
-  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).map((definition) => {
-    const loc = definition.endLine - definition.startLine + 1;
-    const callerRows = getCallerRowsForSymbol(db, definition, { limit: 500 });
-    const calleeRows = getCalleeRowsForSymbol(db, definition, { limit: 500 });
-    const fanIn = new Set(callerRows.map((row) => row.file)).size;
-    const fanOut = new Set(
-      calleeRows.filter((row) => row.file !== definition.relativePath).map((row) => `${row.symbol}|${row.file}`)
-    ).size;
-    const calleeCount = new Set(calleeRows.map((row) => `${row.symbol}|${row.file}`)).size;
-    return {
-      symbol: definition.symbol,
-      shortName: shortenSymbol(definition.symbol),
-      file: definition.relativePath,
-      startLine: definition.startLine,
-      endLine: definition.endLine,
-      loc,
-      fanIn,
-      fanOut,
-      calleeCount,
-      score: Math.round(loc / 50 * (fanIn / 5) * Math.max(fanOut / 5, 1) * 100) / 100
-    };
-  }).filter((row) => row.loc >= minLoc).sort((left, right) => right.score - left.score || right.loc - left.loc).slice(0, limit);
-}
-
-export {
-  complexityHotspots
-};
-//# sourceMappingURL=chunk-Y7FKURZG.js.map

package/dist/chunk-YMSJCSRG.js

@@ -1,213 +0,0 @@
-// src/symbol-parser.ts
-var SUFFIX_MAP = {
-  "/": "namespace",
-  "#": "type",
-  ".": "term",
-  "[": "type-param",
-  ":": "meta",
-  "!": "macro"
-};
-function parseSymbol(raw) {
-  if (raw.startsWith("local ")) {
-    return { kind: "local", id: raw.slice(6), raw };
-  }
-  const parts = raw.split(" ");
-  if (parts.length < 4) {
-    return {
-      scheme: parts[0] ?? "",
-      manager: parts[1] ?? "",
-      packageName: parts[2] ?? "",
-      version: "",
-      descriptors: [],
-      raw
-    };
-  }
-  const scheme = parts[0];
-  const manager = parts[1];
-  let restAfterManager = raw.slice(scheme.length + 1 + manager.length + 1);
-  let packageName;
-  if (restAfterManager.startsWith("`")) {
-    const closingTick = restAfterManager.indexOf("`", 1);
-    if (closingTick === -1) {
-      packageName = restAfterManager.slice(1);
-      restAfterManager = "";
-    } else {
-      packageName = restAfterManager.slice(1, closingTick);
-      restAfterManager = restAfterManager.slice(closingTick + 2);
-    }
-  } else {
-    const spaceIdx = restAfterManager.indexOf(" ");
-    if (spaceIdx === -1) {
-      packageName = restAfterManager;
-      restAfterManager = "";
-    } else {
-      packageName = restAfterManager.slice(0, spaceIdx);
-      restAfterManager = restAfterManager.slice(spaceIdx + 1);
-    }
-  }
-  let version;
-  const versionSpaceIdx = restAfterManager.indexOf(" ");
-  if (versionSpaceIdx === -1) {
-    version = restAfterManager;
-    restAfterManager = "";
-  } else {
-    version = restAfterManager.slice(0, versionSpaceIdx);
-    restAfterManager = restAfterManager.slice(versionSpaceIdx + 1);
-  }
-  const descriptors = parseDescriptors(restAfterManager);
-  return { scheme, manager, packageName, version, descriptors, raw };
-}
-function parseDescriptors(input) {
-  const descriptors = [];
-  let i = 0;
-  while (i < input.length) {
-    if (input[i] === "[") {
-      const closeBracket = input.indexOf("]", i + 1);
-      if (closeBracket === -1) {
-        descriptors.push({ name: input.slice(i + 1), suffix: "type-param" });
-        break;
-      }
-      descriptors.push({ name: input.slice(i + 1, closeBracket), suffix: "type-param" });
-      i = closeBracket + 1;
-      continue;
-    }
-    if (input[i] === "(" && (descriptors.length === 0 || i === 0 || isSuffixChar(input[i - 1]))) {
-      const closeParen = input.indexOf(")", i + 1);
-      if (closeParen !== -1 && input[closeParen + 1] !== ".") {
-        descriptors.push({ name: input.slice(i + 1, closeParen), suffix: "parameter" });
-        i = closeParen + 1;
-        continue;
-      }
-    }
-    let name;
-    if (input[i] === "`") {
-      const closingTick = input.indexOf("`", i + 1);
-      if (closingTick === -1) {
-        name = input.slice(i + 1);
-        descriptors.push({ name, suffix: "term" });
-        break;
-      }
-      name = input.slice(i + 1, closingTick);
-      i = closingTick + 1;
-    } else {
-      const start = i;
-      while (i < input.length && !isSuffixChar(input[i])) {
-        i++;
-      }
-      name = input.slice(start, i);
-    }
-    if (i >= input.length) {
-      if (name) descriptors.push({ name, suffix: "term" });
-      break;
-    }
-    const char = input[i];
-    if (char === "(") {
-      const closeParen = input.indexOf(")", i + 1);
-      if (closeParen !== -1 && input[closeParen + 1] === ".") {
-        descriptors.push({ name, suffix: "method" });
-        i = closeParen + 2;
-      } else if (closeParen !== -1) {
-        descriptors.push({ name, suffix: "method" });
-        i = closeParen + 1;
-      } else {
-        descriptors.push({ name, suffix: "term" });
-        i++;
-      }
-    } else {
-      const suffix = SUFFIX_MAP[char];
-      if (suffix) {
-        descriptors.push({ name, suffix });
-        i += 1;
-      } else {
-        i += 1;
-      }
-    }
-  }
-  return descriptors;
-}
-function isSuffixChar(c) {
-  return c === "/" || c === "#" || c === "." || c === "(" || c === "[" || c === ":" || c === "!";
-}
-function shortenSymbol(raw) {
-  const parsed = parseSymbol(raw);
-  if ("kind" in parsed && parsed.kind === "local") {
-    return `local:${parsed.id}`;
-  }
-  const sym = parsed;
-  if (sym.descriptors.length === 0) return sym.raw;
-  const parts = [];
-  for (const desc of sym.descriptors) {
-    let name = desc.name;
-    if (desc.suffix === "namespace") {
-      name = name.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "").replace(/\.(py|pyi)$/, "").replace(/\.(rs)$/, "").replace(/\.(java|scala|kt|kts)$/, "").replace(/\.(rb)$/, "").replace(/\.(go)$/, "").replace(/\.(cs|vb)$/, "").replace(/\.(dart)$/, "").replace(/\.(php)$/, "").replace(/\.(c|cc|cpp|cxx|h|hpp)$/, "");
-    }
-    if (!name) continue;
-    if (desc.suffix === "method") {
-      parts.push(`${name}()`);
-    } else {
-      parts.push(name);
-    }
-  }
-  return parts.join(":");
-}
-function leafName(raw) {
-  const parsed = parseSymbol(raw);
-  if ("kind" in parsed && parsed.kind === "local") {
-    return parsed.id;
-  }
-  const sym = parsed;
-  if (sym.descriptors.length === 0) return "";
-  const last = sym.descriptors[sym.descriptors.length - 1];
-  return last.name;
-}
-function leafSuffix(raw) {
-  const parsed = parseSymbol(raw);
-  if ("kind" in parsed && parsed.kind === "local") {
-    return null;
-  }
-  const sym = parsed;
-  const last = sym.descriptors[sym.descriptors.length - 1];
-  return last?.suffix ?? null;
-}
-function isCallableSymbol(raw) {
-  return raw.endsWith("().") || leafSuffix(raw) === "method";
-}
-function isFunctionLikeSymbol(raw) {
-  const suffix = leafSuffix(raw);
-  return suffix === "method" || suffix === "term";
-}
-function isModuleLikeSymbol(raw) {
-  return leafSuffix(raw) === "namespace";
-}
-function isDirectChildSymbol(parentRaw, candidateRaw) {
-  const parent = parseSymbol(parentRaw);
-  const candidate = parseSymbol(candidateRaw);
-  if ("kind" in parent || "kind" in candidate) {
-    return false;
-  }
-  const parentDescriptors = parent.descriptors;
-  const candidateDescriptors = candidate.descriptors;
-  if (candidateDescriptors.length !== parentDescriptors.length + 1) {
-    return false;
-  }
-  for (let i = 0; i < parentDescriptors.length; i++) {
-    const parentDesc = parentDescriptors[i];
-    const candidateDesc = candidateDescriptors[i];
-    if (parentDesc.name !== candidateDesc.name || parentDesc.suffix !== candidateDesc.suffix) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export {
-  parseSymbol,
-  shortenSymbol,
-  leafName,
-  leafSuffix,
-  isCallableSymbol,
-  isFunctionLikeSymbol,
-  isModuleLikeSymbol,
-  isDirectChildSymbol
-};
-//# sourceMappingURL=chunk-YMSJCSRG.js.map