scip-query 0.3.5 → 0.4.0

package/dist/chunk-NWCJWA36.js

@@ -0,0 +1,162 @@
+import {
+  getAllDefinitions,
+  getSourceText
+} from "./chunk-QGCEAVJD.js";
+import {
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/similar-signatures.ts
+function similarSignatures(db, opts = {}) {
+  const { scope, minLoc = 1, limit } = opts;
+  const sigGroups = /* @__PURE__ */ new Map();
+  for (const definition of getAllDefinitions(db, { scope })) {
+    if (!definition.isFunctionLike || db.isIgnored(definition.relativePath)) continue;
+    const loc = definition.endLine - definition.startLine + 1;
+    if (loc < minLoc) continue;
+    const normalized = resolveNormalizedSignature(db, definition);
+    if (!normalized) continue;
+    const entry = {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      file: definition.relativePath,
+      startLine: definition.startLine,
+      endLine: definition.endLine,
+      loc
+    };
+    const existing = sigGroups.get(normalized);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      sigGroups.set(normalized, [entry]);
+    }
+  }
+  const results = [];
+  for (const [signature, functions] of sigGroups) {
+    if (functions.length < 2) continue;
+    results.push({ signature, functions });
+  }
+  results.sort((a, b) => {
+    const sizeDiff = b.functions.length - a.functions.length;
+    if (sizeDiff !== 0) return sizeDiff;
+    const locA = a.functions.reduce((sum, f) => sum + f.loc, 0);
+    const locB = b.functions.reduce((sum, f) => sum + f.loc, 0);
+    return locB - locA;
+  });
+  return limit ? results.slice(0, limit) : results;
+}
+function resolveNormalizedSignature(db, definition) {
+  const documented = extractDocumentedSignature(definition.documentation);
+  const normalizedDocumented = documented ? normalizeSignature(documented) : null;
+  if (normalizedDocumented) {
+    return normalizedDocumented;
+  }
+  return normalizeSourceSignature(
+    extractDeclarationHead(db, definition.relativePath, definition.startLine, definition.endLine, definition.leaf),
+    definition.leaf
+  );
+}
+function extractDocumentedSignature(documentation) {
+  if (!documentation || !documentation.includes("|")) {
+    return null;
+  }
+  const extracted = documentation.slice(documentation.indexOf("|") + 1).replace(/\n/g, " ").trim();
+  return extracted.length > 0 ? extracted : null;
+}
+function extractDeclarationHead(db, relativePath, startLine, endLine, leaf) {
+  const source = getSourceText(db, relativePath);
+  if (!source) return null;
+  const lines = source.split(/\r?\n/);
+  const candidates = declarationStartLines(lines, startLine, endLine, leaf);
+  for (const candidate of candidates) {
+    const maxLine = Math.min(lines.length - 1, Math.max(candidate, candidate + 4));
+    let collected = "";
+    for (let lineIndex = candidate; lineIndex <= maxLine; lineIndex += 1) {
+      const line = lines[lineIndex]?.trim();
+      if (!line) continue;
+      collected = collected ? `${collected} ${line}` : line;
+      if (looksCompleteDeclaration(collected)) {
+        return collected;
+      }
+    }
+    if (collected && collected.includes("(")) {
+      return collected;
+    }
+  }
+  return null;
+}
+function looksCompleteDeclaration(declaration) {
+  const normalized = declaration.replace(/\s+/g, " ").trim();
+  if (!normalized.includes("(")) return false;
+  if (parenBalance(normalized) > 0) return false;
+  return /[;{]$/.test(normalized) || /\)\s*(?::\s*[^={]+)?\s*(?:=>|=|throws\b|where\b|$)/i.test(normalized) || /\)\s*As\s+.+$/i.test(normalized);
+}
+function normalizeSignature(raw) {
+  if (!raw || !raw.trim()) return null;
+  let sig = raw.replace(/^```\w*\s*/, "").replace(/\s*```$/, "").replace(/^\(method\)\s*/, "").replace(/^\(property\)\s*/, "").replace(/^\(function\)\s*/, "").replace(/^\(class\)\s*/, "").replace(/^\(interface\)\s*/, "").replace(/^\(enum\)\s*/, "").replace(/^\(type alias\)\s*/, "").replace(/^\(const\)\s*/, "").replace(/^\(var\)\s*/, "").trim();
+  const parenIdx = sig.indexOf("(");
+  if (parenIdx === -1) return null;
+  sig = sig.slice(parenIdx);
+  sig = sig.replace(/\s+/g, "").toLowerCase();
+  if (sig.length < 3) return null;
+  return sig;
+}
+function normalizeSourceSignature(raw, leaf) {
+  if (!raw || !raw.trim()) return null;
+  let declaration = raw.replace(/\s+/g, " ").trim();
+  const parenIdx = declaration.indexOf("(");
+  if (parenIdx === -1) return null;
+  let prefix = declaration.slice(0, parenIdx);
+  const leafPattern = new RegExp(`\\b${escapeRegex(leaf)}\\b`, "i");
+  const leafMatch = leafPattern.exec(prefix);
+  if (leafMatch && typeof leafMatch.index === "number") {
+    prefix = prefix.slice(0, leafMatch.index);
+  }
+  prefix = prefix.replace(/\b(public|private|protected|internal|final|static|abstract|sealed|virtual|override|async|suspend|inline|constexpr|consteval|constinit|const|pub|fn|function|def|sub|friend|shared|readonly|new|open|partial|export)\b/gi, " ").replace(/\s+/g, " ").trim();
+  let suffix = declaration.slice(parenIdx).replace(/\s*\{[\s\S]*$/, "").replace(/\s*=>[\s\S]*$/, "").replace(/\)\s*=\s*[\s\S]*$/, ")").replace(/\s+throws\s+[^={]+$/i, "").replace(/\s+where\s+.+$/i, "").replace(/\s+/g, " ").trim();
+  if (!suffix.startsWith("(")) {
+    return null;
+  }
+  const normalized = `${prefix ? `${prefix} ` : ""}${suffix}`.replace(/\s+/g, "").toLowerCase();
+  return normalized.length >= 3 ? normalized : null;
+}
+function declarationStartLines(lines, startLine, endLine, leaf) {
+  const escapedLeaf = escapeRegex(leaf);
+  const callablePattern = new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`, "i");
+  const rubyPattern = new RegExp(`\\bdef\\s+${escapedLeaf}\\b`, "i");
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const preferredStart = Math.max(0, Math.min(startLine, lines.length - 1));
+  const preferredEnd = Math.max(preferredStart, Math.min(lines.length - 1, Math.max(endLine, startLine + 4)));
+  for (let lineIndex = preferredStart; lineIndex <= preferredEnd; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if ((callablePattern.test(line) || rubyPattern.test(line)) && !seen.has(lineIndex)) {
+      seen.add(lineIndex);
+      candidates.push(lineIndex);
+    }
+  }
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if ((callablePattern.test(line) || rubyPattern.test(line)) && !seen.has(lineIndex)) {
+      seen.add(lineIndex);
+      candidates.push(lineIndex);
+    }
+  }
+  return candidates;
+}
+function parenBalance(value) {
+  let balance = 0;
+  for (const char of value) {
+    if (char === "(") balance += 1;
+    if (char === ")") balance -= 1;
+  }
+  return balance;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export {
+  similarSignatures
+};
+//# sourceMappingURL=chunk-NWCJWA36.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-P3E6L7KW.js → chunk-P42KQKJZ.js}

@@ -1,7 +1,13 @@
 import {
   isLiveBarrel
-} from "./chunk-YY4QGUQ5.js";
+} from "./chunk-X3J4VPWM.js";
 import {
+  getDefinitionsForFile,
+  getSourceExports,
+  getSourceImports
+} from "./chunk-QGCEAVJD.js";
+import {
+  leafSuffix,
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
 
@@ -96,10 +102,84 @@ function redundantReexports(db, opts = {}) {
   results.sort(
     (a, b) => b.directConsumers - a.directConsumers || a.barrelFile.localeCompare(b.barrelFile) || a.shortName.localeCompare(b.shortName)
   );
-  return limit ? results.slice(0, limit) : results;
+  const withDartFallback = dedupeReexports([
+    ...results,
+    ...findSourceRedundantReexports(db, scope)
+  ]);
+  withDartFallback.sort(
+    (a, b) => b.directConsumers - a.directConsumers || a.barrelFile.localeCompare(b.barrelFile) || a.shortName.localeCompare(b.shortName)
+  );
+  return limit ? withDartFallback.slice(0, limit) : withDartFallback;
+}
+function findSourceRedundantReexports(db, scope) {
+  const files = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${scope ? "AND relative_path LIKE ?" : ""}
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`,
+    ...scope ? [`%${scope}%`] : []
+  );
+  const candidates = files.map((row) => row.relative_path).filter((relativePath) => !db.isIgnored(relativePath)).filter((relativePath) => getSourceExports(db, relativePath).length > 0);
+  const results = [];
+  for (const barrelPath of candidates) {
+    const exports = getSourceExports(db, barrelPath).filter((entry) => entry.sourcePath && !db.isIgnored(entry.sourcePath));
+    if (exports.length === 0) continue;
+    const barrelConsumers = countDirectImporters(db, barrelPath, barrelPath);
+    if (barrelConsumers > 0) continue;
+    for (const exported of exports) {
+      const sourcePath = exported.sourcePath;
+      const representative = representativeExportSymbol(db, sourcePath);
+      if (!representative) continue;
+      results.push({
+        barrelFile: barrelPath,
+        symbol: representative.symbol,
+        shortName: shortenSymbol(representative.symbol),
+        originalFile: sourcePath,
+        barrelConsumers: 0,
+        directConsumers: countDirectImporters(db, sourcePath, barrelPath)
+      });
+    }
+  }
+  return results;
+}
+function countDirectImporters(db, targetPath, excludedPath) {
+  const files = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const importers = /* @__PURE__ */ new Set();
+  for (const row of files) {
+    if (db.isIgnored(row.relative_path) || row.relative_path === excludedPath) continue;
+    for (const imported of getSourceImports(db, row.relative_path)) {
+      if (imported.sourcePath === targetPath) {
+        importers.add(row.relative_path);
+      }
+    }
+  }
+  return importers.size;
+}
+function representativeExportSymbol(db, sourcePath) {
+  const definitions = getDefinitionsForFile(db, sourcePath);
+  return definitions.find((definition) => leafSuffix(definition.symbol) === "method") ?? definitions[0] ?? null;
+}
+function dedupeReexports(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.barrelFile}|${row.symbol}|${row.originalFile}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
 }
 
 export {
   redundantReexports
 };
-//# sourceMappingURL=chunk-P3E6L7KW.js.map
+//# sourceMappingURL=chunk-P42KQKJZ.js.map

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

@@ -1,6 +1,6 @@
 import {
   findFirstSymbolMatch
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   parseSymbol,
   shortenSymbol
@@ -66,4 +66,4 @@ function hierarchy(db, symbolPattern) {
 export {
   hierarchy
 };
-//# sourceMappingURL=chunk-YDBXNPYU.js.map
+//# sourceMappingURL=chunk-PGHN5UTM.js.map

package/dist/{chunk-UGQKAVCD.js → chunk-QCYR4S6T.js}

@@ -1,7 +1,7 @@
 import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -107,4 +107,4 @@ function stripCommentsAndStrings(source) {
 export {
   complexity
 };
-//# sourceMappingURL=chunk-UGQKAVCD.js.map
+//# sourceMappingURL=chunk-QCYR4S6T.js.map