scip-query 0.3.5 → 0.4.1

package/dist/chunk-NXUIWD6K.js

@@ -0,0 +1,87 @@
+import {
+  findExactSymbolMatch,
+  findFirstSymbolMatch,
+  getCallerRowsForSymbol
+} from "./chunk-ALUFWH3U.js";
+import {
+  shortenSymbol
+} from "./chunk-TO3L4YNK.js";
+
+// src/queries/affected.ts
+function affected(db, symbolPattern, opts = {}) {
+  const { maxDepth = 5, scope } = opts;
+  const target = findFirstSymbolMatch(db, symbolPattern);
+  if (!target) return [];
+  const results = [];
+  const visited = /* @__PURE__ */ new Set([target.symbolId]);
+  const seenResults = /* @__PURE__ */ new Set();
+  let frontier = [target];
+  for (let depth = 1; depth <= maxDepth; depth++) {
+    if (frontier.length === 0) break;
+    const nextFrontier = [];
+    for (const current of frontier) {
+      for (const row of getDirectAffectedRows(db, current, scope)) {
+        const resultKey = `${row.file}|${row.shortName}`;
+        if (row.symbolId !== null) {
+          if (visited.has(row.symbolId)) continue;
+          visited.add(row.symbolId);
+        } else if (seenResults.has(resultKey)) {
+          continue;
+        }
+        seenResults.add(resultKey);
+        results.push({
+          symbol: row.symbol,
+          shortName: row.shortName,
+          file: row.file,
+          depth
+        });
+        if (row.symbolId !== null && row.symbolMatch) {
+          nextFrontier.push(row.symbolMatch);
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  results.sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));
+  return results;
+}
+function getDirectAffectedRows(db, target, scope) {
+  const callerRows = getCallerRowsForSymbol(db, target, { limit: 500 }).filter((row) => !db.isIgnored(row.file)).filter((row) => !scope || row.file.includes(scope));
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of callerRows) {
+    const match = findExactSymbolMatch(db, row.symbol);
+    if (!match) {
+      const key2 = `${row.file}|${row.symbol}`;
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      results.push({
+        symbolId: null,
+        symbol: row.symbol,
+        shortName: shortenSymbol(row.symbol),
+        file: row.file,
+        symbolMatch: null
+      });
+      continue;
+    }
+    if (match.symbolId === target.symbolId || db.isIgnored(match.relativePath)) {
+      continue;
+    }
+    const key = `${match.symbolId}|${match.relativePath}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({
+      symbolId: match.symbolId,
+      symbol: match.symbol,
+      shortName: shortenSymbol(match.symbol),
+      file: match.relativePath,
+      symbolMatch: match
+    });
+  }
+  return results;
+}
+
+export {
+  affected
+};
+//# sourceMappingURL=chunk-NXUIWD6K.js.map

package/dist/{chunk-LFJQVJYJ.js → chunk-OXX3QF24.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 
 // src/queries/cycles.ts
 function cycles(db, opts = {}) {
@@ -58,4 +58,4 @@ function cycles(db, opts = {}) {
 export {
   cycles
 };
-//# sourceMappingURL=chunk-LFJQVJYJ.js.map
+//# sourceMappingURL=chunk-OXX3QF24.js.map

package/dist/{chunk-NG5F43OU.js → chunk-P3VCDYMJ.js}

@@ -1,6 +1,8 @@
 // src/reindex/install.ts
 import { execFileSync } from "child_process";
+import { existsSync } from "fs";
 import { platform } from "os";
+import { join } from "path";
 var IS_WINDOWS = platform() === "win32";
 function isBinaryAvailable(name) {
   const cmd = IS_WINDOWS ? "where" : "which";
@@ -29,6 +31,31 @@ function resolveIndexerBinary(config) {
 function isIndexerInstalled(config) {
   return resolveIndexerBinary(config) !== null;
 }
+function resolveProjectLocalIndexerBinary(config, projectRoot) {
+  for (const relativePath of config.projectLocalBinaries ?? []) {
+    const candidate = join(projectRoot, relativePath);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function getIndexerExecutionEnv(config, baseEnv = process.env, binary = config.indexerBinary) {
+  if (config.indexerBinary !== "scip-dotnet") {
+    return baseEnv;
+  }
+  if (canRunDotnetIndexer(binary, baseEnv)) {
+    return baseEnv;
+  }
+  const dotnetRoot = resolveWorkingDotnetRoot(binary, baseEnv);
+  if (!dotnetRoot) {
+    return baseEnv;
+  }
+  return {
+    ...baseEnv,
+    DOTNET_ROOT: dotnetRoot
+  };
+}
 function tryInstallIndexer(config, onStatus) {
   const methods = config.installMethods;
   const binaryLabel = describeIndexerBinary(config);
@@ -68,6 +95,46 @@ function tryInstallIndexer(config, onStatus) {
   }
   return false;
 }
+function resolveWorkingDotnetRoot(binary, env) {
+  for (const dotnetRoot of getDotnetRootCandidates(env)) {
+    if (canRunDotnetIndexer(binary, { ...env, DOTNET_ROOT: dotnetRoot })) {
+      return dotnetRoot;
+    }
+  }
+  return null;
+}
+function getDotnetRootCandidates(env) {
+  const candidates = [];
+  const configured = env["DOTNET_ROOT"];
+  if (configured && existsSync(configured)) {
+    candidates.push(configured);
+  }
+  if (platform() === "darwin" && isBinaryAvailable("brew")) {
+    try {
+      const prefix = execFileSync("brew", ["--prefix", "dotnet@9"], {
+        stdio: "pipe",
+        env
+      }).toString().trim();
+      const candidate = join(prefix, "libexec");
+      if (existsSync(candidate) && !candidates.includes(candidate)) {
+        candidates.push(candidate);
+      }
+    } catch {
+    }
+  }
+  return candidates;
+}
+function canRunDotnetIndexer(binary, env) {
+  try {
+    execFileSync(binary, ["--version"], {
+      stdio: "pipe",
+      env
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/scip-cli.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -191,10 +258,12 @@ export {
   describeIndexerBinary,
   resolveIndexerBinary,
   isIndexerInstalled,
+  resolveProjectLocalIndexerBinary,
+  getIndexerExecutionEnv,
   tryInstallIndexer,
   isScipInstalled,
   getScipVersion,
   printScipInstallInstructions,
   tryInstallScipCli
 };
-//# sourceMappingURL=chunk-NG5F43OU.js.map
+//# sourceMappingURL=chunk-P3VCDYMJ.js.map

package/dist/{chunk-7HK5ZLOE.js → chunk-PCU455MX.js}

@@ -1,6 +1,6 @@
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/diff-impact.ts
 import { execFileSync } from "child_process";
@@ -148,4 +148,4 @@ function getChangedFiles(projectRoot, base) {
 export {
   diffImpact
 };
-//# sourceMappingURL=chunk-7HK5ZLOE.js.map
+//# sourceMappingURL=chunk-PCU455MX.js.map

package/dist/{chunk-O7Q7FDUJ.js → chunk-POLELLNM.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-4TYLS5XX.js";
 import {
   resolveIndexedPaths
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/system.ts
 function system(db, modulePattern) {
@@ -79,4 +79,4 @@ function system(db, modulePattern) {
 export {
   system
 };
-//# sourceMappingURL=chunk-O7Q7FDUJ.js.map
+//# sourceMappingURL=chunk-POLELLNM.js.map

package/dist/chunk-PU2254N2.js

@@ -0,0 +1,115 @@
+import {
+  buildFileDepGraph,
+  getCallerRowsForSymbol,
+  getDefinitionsForFile
+} from "./chunk-ALUFWH3U.js";
+import {
+  isFunctionLikeSymbol,
+  shortenSymbol
+} from "./chunk-TO3L4YNK.js";
+
+// src/queries/wrapper-candidates.ts
+import { basename, extname } from "path";
+function wrapperCandidates(db, opts) {
+  const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
+  const reverseFanIn = buildReverseFileFanIn(buildFileDepGraph(db, scope));
+  const symbols = getScopedDefinitions(db, scope).filter((definition) => definitionLoc(definition) <= maxLoc && definitionLoc(definition) >= 2);
+  const results = [];
+  for (const symbol of symbols) {
+    if (db.isIgnored(symbol.relativePath) || !isFunctionLikeSymbol(symbol.symbol)) continue;
+    const symbolStem = basename(symbol.relativePath, extname(symbol.relativePath));
+    const callerRows = dedupeRows(
+      getCallerRowsForSymbol(db, symbol, { limit: 200 }).filter((row) => row.file !== symbol.relativePath)
+    ).filter((row) => basename(row.file, extname(row.file)) !== symbolStem);
+    if (callerRows.length !== 1) continue;
+    const caller = callerRows[0];
+    const callerDefinition = getDefinitionsForFile(db, caller.file).find((definition) => definition.symbol === caller.symbol);
+    const useDefinitionFanIn = callerDefinition?.isFunctionLike ?? false;
+    let callerFanIn;
+    if (useDefinitionFanIn && callerDefinition) {
+      callerFanIn = new Set(
+        getCallerRowsForSymbol(db, callerDefinition, { limit: 500 }).filter((row) => row.file !== callerDefinition.relativePath).map((row) => row.file)
+      ).size;
+    } else {
+      callerFanIn = fallbackCallerFanIn(db, reverseFanIn, caller.file);
+    }
+    if (callerFanIn <= 3) continue;
+    results.push({
+      symbol: symbol.symbol,
+      shortName: shortenSymbol(symbol.symbol),
+      file: symbol.relativePath,
+      startLine: symbol.startLine,
+      endLine: symbol.endLine,
+      loc: definitionLoc(symbol),
+      singleCaller: caller.symbol,
+      singleCallerShort: useDefinitionFanIn ? shortenSymbol(caller.symbol) : basename(caller.file),
+      callerFanIn
+    });
+  }
+  results.sort((left, right) => right.callerFanIn - left.callerFanIn || right.loc - left.loc);
+  return results.slice(0, limit);
+}
+function definitionLoc(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
+function getScopedDefinitions(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+function dedupeRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.symbol}|${row.file}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
+}
+function buildReverseFileFanIn(graph) {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [fromFile, deps] of graph) {
+    if (!reverse.has(fromFile)) {
+      reverse.set(fromFile, reverse.get(fromFile) ?? 0);
+    }
+    for (const dep of deps) {
+      reverse.set(dep, (reverse.get(dep) ?? 0) + 1);
+    }
+  }
+  return reverse;
+}
+function fallbackCallerFanIn(db, reverseFanIn, callerFile) {
+  const functionLikeFanIn = getDefinitionsForFile(db, callerFile).filter((definition) => definition.isFunctionLike).map((definition) => new Set(
+    getCallerRowsForSymbol(db, definition, { limit: 500 }).filter((row) => row.file !== definition.relativePath).map((row) => row.file)
+  ).size).sort((left, right) => right - left)[0] ?? 0;
+  if (functionLikeFanIn > 0) {
+    return functionLikeFanIn;
+  }
+  const direct = reverseFanIn.get(callerFile) ?? 0;
+  if (direct > 0) {
+    return direct;
+  }
+  const stem = basename(callerFile, extname(callerFile));
+  let best = 0;
+  for (const [file, fanIn] of reverseFanIn) {
+    if (file === callerFile) continue;
+    if (basename(file, extname(file)) !== stem) continue;
+    if (fanIn > best) {
+      best = fanIn;
+    }
+  }
+  return best;
+}
+
+export {
+  wrapperCandidates
+};
+//# sourceMappingURL=chunk-PU2254N2.js.map

package/dist/{chunk-WGAD3GNR.js → chunk-QMXSLHZP.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 
 // src/queries/similar-chains.ts
 function similarChains(db, opts = {}) {
@@ -28,8 +28,8 @@ function similarChains(db, opts = {}) {
       tailFreq.set(chain[t], (tailFreq.get(chain[t]) ?? 0) + 1);
     }
   }
-  const infraThreshold = rawChains.length * 0.4;
-  const tailThreshold = rawChains.length * 0.3;
+  const infraThreshold = rawChains.length * 0.9;
+  const tailThreshold = rawChains.length * 0.8;
   const infraNodes = /* @__PURE__ */ new Set();
   for (const [node, freq] of nodeFreq) {
     if (freq > infraThreshold) infraNodes.add(node);
@@ -45,7 +45,7 @@ function similarChains(db, opts = {}) {
   const filteredChains = [];
   for (const chain of rawChains) {
     const filtered = chain.filter((n) => !infraNodes.has(n));
-    if (filtered.length >= 3) {
+    if (filtered.length >= 2) {
       filteredChains.push({ original: chain, filtered });
     }
   }
@@ -210,4 +210,4 @@ function isSubChain(sub, full) {
 export {
   similarChains
 };
-//# sourceMappingURL=chunk-WGAD3GNR.js.map
+//# sourceMappingURL=chunk-QMXSLHZP.js.map

package/dist/{chunk-YDBXNPYU.js → chunk-R7HPHMRZ.js}

@@ -1,10 +1,10 @@
 import {
   findFirstSymbolMatch
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   parseSymbol,
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/hierarchy.ts
 function hierarchy(db, symbolPattern) {
@@ -66,4 +66,4 @@ function hierarchy(db, symbolPattern) {
 export {
   hierarchy
 };
-//# sourceMappingURL=chunk-YDBXNPYU.js.map
+//# sourceMappingURL=chunk-R7HPHMRZ.js.map

package/dist/{chunk-HLUS2HEB.js → chunk-RE7POFGI.js}

@@ -1,10 +1,11 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 
 // src/queries/similar-files.ts
 function similarFiles(db, opts = {}) {
-  const { minSimilarity = 0.5, limit = 20, scope, minDeps = 3, filePattern } = opts;
+  const { minSimilarity = 0.5, limit = 20, scope, filePattern } = opts;
+  const minDeps = opts.minDeps ?? (filePattern ? 1 : 3);
   const profiles = buildFileProfiles(db, { scope, minDeps });
   const results = [];
   if (filePattern) {
@@ -53,7 +54,7 @@ function findUniversalDependencies(depMap) {
     }
   }
   for (const [dep, count] of depCounts) {
-    if (count / fileCount > 0.5) {
+    if (count >= 6 && count / fileCount > 0.8) {
       universalDeps.add(dep);
     }
   }
@@ -89,4 +90,4 @@ function compareProfiles(a, b, minSimilarity) {
 export {
   similarFiles
 };
-//# sourceMappingURL=chunk-HLUS2HEB.js.map
+//# sourceMappingURL=chunk-RE7POFGI.js.map

package/dist/{chunk-VT4JBH6L.js → chunk-RJ5GULL6.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 
 // src/queries/deps.ts
 function deps(db, filePattern) {
@@ -50,4 +50,4 @@ export {
   deps,
   rdeps
 };
-//# sourceMappingURL=chunk-VT4JBH6L.js.map
+//# sourceMappingURL=chunk-RJ5GULL6.js.map

package/dist/{chunk-7KIMF5PV.js → chunk-RL74LF47.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 
 // src/queries/drift.ts
 import path from "path";
@@ -162,4 +162,4 @@ function isTestLikePath(filePath) {
 export {
   drift
 };
-//# sourceMappingURL=chunk-7KIMF5PV.js.map
+//# sourceMappingURL=chunk-RL74LF47.js.map

package/dist/chunk-SVLUJSY7.js

@@ -0,0 +1,75 @@
+import {
+  getDefinitionsForFile
+} from "./chunk-ALUFWH3U.js";
+import {
+  shortenSymbol
+} from "./chunk-TO3L4YNK.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 getScopedDefinitions(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
+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-SVLUJSY7.js.map

package/dist/chunk-SYQR4QGK.js

@@ -0,0 +1,38 @@
+import {
+  cleanSignature
+} from "./chunk-4TYLS5XX.js";
+import {
+  getDefinitionsForFile,
+  resolveIndexedPaths
+} from "./chunk-ALUFWH3U.js";
+import {
+  shortenSymbol
+} from "./chunk-TO3L4YNK.js";
+
+// src/queries/symbols.ts
+function symbols(db, filePattern) {
+  const resolvedPaths = resolveIndexedPaths(db, filePattern);
+  if (resolvedPaths.length === 0) {
+    return [];
+  }
+  return resolvedPaths.flatMap((relativePath) => getDefinitionsForFile(db, relativePath)).filter((row) => !db.isIgnored(row.relativePath)).map((row) => {
+    const docRow = db.get(
+      `SELECT REPLACE(SUBSTR(documentation, INSTR(documentation, '|') + 1), char(10), ' ') AS sig
+         FROM global_symbols
+         WHERE id = ?`,
+      row.symbolId
+    );
+    return {
+      startLine: row.startLine,
+      endLine: row.endLine,
+      symbol: row.symbol,
+      shortName: shortenSymbol(row.symbol),
+      signature: cleanSignature(docRow?.sig ?? null)
+    };
+  });
+}
+
+export {
+  symbols
+};
+//# sourceMappingURL=chunk-SYQR4QGK.js.map

package/dist/{chunk-QIXNAB5K.js → chunk-TO3L4YNK.js}

@@ -84,7 +84,6 @@ function parseDescriptors(input) {
       const closingTick = input.indexOf("`", i + 1);
       if (closingTick === -1) {
         name = input.slice(i + 1);
-        i = input.length;
         descriptors.push({ name, suffix: "term" });
         break;
       }
@@ -207,4 +206,4 @@ export {
   isModuleLikeSymbol,
   isDirectChildSymbol
 };
-//# sourceMappingURL=chunk-QIXNAB5K.js.map
+//# sourceMappingURL=chunk-TO3L4YNK.js.map