@liendev/lien 0.26.0 → 0.27.0

package/dist/index.js

@@ -8334,6 +8334,9 @@ var GetDependentsSchema = external_exports.object({
   filepath: external_exports.string().min(1, "Filepath cannot be empty").describe(
     "Path to file to find dependents for (relative to workspace root).\n\nExample: 'src/utils/validate.ts'\n\nReturns all files that import or depend on this file.\n\nNote: Scans up to 10,000 code chunks. For very large codebases,\nresults may be incomplete (a warning will be included if truncated)."
   ),
+  symbol: external_exports.string().min(1, "Symbol cannot be an empty string").optional().describe(
+    "Optional: specific exported symbol to find usages of.\n\nWhen provided, returns call sites instead of just importing files.\n\nExample: 'validateEmail' to find where validateEmail() is called.\n\nResponse includes 'usages' array showing which functions call this symbol."
+  ),
   depth: external_exports.number().int().min(1).max(1).default(1).describe(
     "Depth of transitive dependencies. Only depth=1 (direct dependents) is currently supported.\n\n1 = Direct dependents only"
   ),
@@ -8643,7 +8646,7 @@ async function handleFindSimilar(args, ctx) {
 // src/mcp/utils/path-matching.ts
 function normalizePath(path6, workspaceRoot) {
   let normalized = path6.replace(/['"]/g, "").trim().replace(/\\/g, "/");
-  normalized = normalized.replace(/\.(ts|tsx|js|jsx)$/, "");
+  normalized = normalized.replace(/\.(ts|tsx|js|jsx|php|py)$/, "");
   if (normalized.startsWith(workspaceRoot + "/")) {
     normalized = normalized.substring(workspaceRoot.length + 1);
   }
@@ -8671,8 +8674,56 @@ function matchesFile(normalizedImport, normalizedTarget) {
   if (matchesAtBoundary(cleanedImport, normalizedTarget) || matchesAtBoundary(normalizedTarget, cleanedImport)) {
     return true;
   }
+  if (matchesPHPNamespace(normalizedImport, normalizedTarget)) {
+    return true;
+  }
+  if (matchesPythonModule(normalizedImport, normalizedTarget)) {
+    return true;
+  }
   return false;
 }
+function matchesDirectPythonModule(moduleAsPath, targetWithoutPy) {
+  return targetWithoutPy === moduleAsPath || targetWithoutPy === moduleAsPath + "/__init__" || targetWithoutPy.replace(/\/__init__$/, "") === moduleAsPath;
+}
+function matchesParentPythonPackage(moduleAsPath, targetWithoutPy) {
+  return targetWithoutPy.startsWith(moduleAsPath + "/");
+}
+function matchesSuffixPythonModule(moduleAsPath, targetWithoutPy) {
+  return targetWithoutPy.endsWith("/" + moduleAsPath) || targetWithoutPy.endsWith("/" + moduleAsPath + "/__init__");
+}
+function matchesWithSourcePrefix(moduleAsPath, targetWithoutPy) {
+  const moduleIndex = targetWithoutPy.indexOf(moduleAsPath);
+  if (moduleIndex < 0) return false;
+  const prefix = targetWithoutPy.substring(0, moduleIndex);
+  const prefixSlashes = (prefix.match(/\//g) || []).length;
+  return prefixSlashes <= 1 && (prefix === "" || prefix.endsWith("/"));
+}
+function matchesPythonModule(importPath, targetPath) {
+  if (!importPath.includes(".")) {
+    return false;
+  }
+  const moduleAsPath = importPath.replace(/\./g, "/");
+  const targetWithoutPy = targetPath.replace(/\.py$/, "");
+  return matchesDirectPythonModule(moduleAsPath, targetWithoutPy) || matchesParentPythonPackage(moduleAsPath, targetWithoutPy) || matchesSuffixPythonModule(moduleAsPath, targetWithoutPy) || matchesWithSourcePrefix(moduleAsPath, targetWithoutPy);
+}
+function matchesPHPNamespace(importPath, targetPath) {
+  const importComponents = importPath.split("/").filter(Boolean);
+  const targetComponents = targetPath.split("/").filter(Boolean);
+  if (importComponents.length === 0 || targetComponents.length === 0) {
+    return false;
+  }
+  let matched = 0;
+  for (let i = 1; i <= importComponents.length && i <= targetComponents.length; i++) {
+    const impComp = importComponents[importComponents.length - i].toLowerCase();
+    const targetComp = targetComponents[targetComponents.length - i].toLowerCase();
+    if (impComp === targetComp) {
+      matched++;
+    } else {
+      break;
+    }
+  }
+  return matched === importComponents.length;
+}
 function getCanonicalPath(filepath, workspaceRoot) {
   let canonical = filepath.replace(/\\/g, "/");
   if (canonical.startsWith(workspaceRoot + "/")) {
@@ -8942,7 +8993,7 @@ var COMPLEXITY_THRESHOLDS = {
   MEDIUM_MAX: 15
   // Occasional branching
 };
-async function findDependents(vectorDB, filepath, crossRepo, log) {
+async function scanChunks(vectorDB, crossRepo, log) {
   let allChunks;
   if (crossRepo && vectorDB instanceof QdrantDB2) {
     allChunks = await vectorDB.scanCrossRepo({ limit: SCAN_LIMIT2 });
@@ -8956,48 +9007,105 @@ async function findDependents(vectorDB, filepath, crossRepo, log) {
   if (hitLimit) {
     log(`Scanned ${SCAN_LIMIT2} chunks (limit reached). Results may be incomplete.`, "warning");
   }
-  log(`Scanning ${allChunks.length} chunks for imports...`);
+  return { allChunks, hitLimit };
+}
+function createPathNormalizer() {
   const workspaceRoot = process.cwd().replace(/\\/g, "/");
-  const pathCache = /* @__PURE__ */ new Map();
-  const normalizePathCached = (path6) => {
-    if (!pathCache.has(path6)) pathCache.set(path6, normalizePath(path6, workspaceRoot));
-    return pathCache.get(path6);
+  const cache = /* @__PURE__ */ new Map();
+  return (path6) => {
+    if (!cache.has(path6)) {
+      cache.set(path6, normalizePath(path6, workspaceRoot));
+    }
+    return cache.get(path6);
   };
-  const importIndex = buildImportIndex(allChunks, normalizePathCached);
-  const normalizedTarget = normalizePathCached(filepath);
-  const dependentChunks = findDependentChunks(importIndex, normalizedTarget);
+}
+function groupChunksByFile(chunks) {
+  const workspaceRoot = process.cwd().replace(/\\/g, "/");
   const chunksByFile = /* @__PURE__ */ new Map();
-  for (const chunk of dependentChunks) {
+  for (const chunk of chunks) {
     const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
     const existing = chunksByFile.get(canonical) || [];
     existing.push(chunk);
     chunksByFile.set(canonical, existing);
   }
+  return chunksByFile;
+}
+function buildDependentsList(chunksByFile, symbol, normalizedTarget, normalizePathCached, allChunks, filepath, log) {
+  if (symbol) {
+    validateSymbolExport(allChunks, normalizedTarget, normalizePathCached, symbol, filepath, log);
+    return findSymbolUsages(chunksByFile, symbol, normalizedTarget, normalizePathCached);
+  }
+  const dependents = Array.from(chunksByFile.keys()).map((fp) => ({
+    filepath: fp,
+    isTestFile: isTestFile(fp)
+  }));
+  return { dependents, totalUsageCount: void 0 };
+}
+function validateSymbolExport(allChunks, normalizedTarget, normalizePathCached, symbol, filepath, log) {
+  const targetFileExportsSymbol = allChunks.some((chunk) => {
+    const chunkFile = normalizePathCached(chunk.metadata.file);
+    return matchesFile(chunkFile, normalizedTarget) && chunk.metadata.exports?.includes(symbol);
+  });
+  if (!targetFileExportsSymbol) {
+    log(`Warning: Symbol "${symbol}" not found in exports of ${filepath}`, "warning");
+  }
+}
+async function findDependents(vectorDB, filepath, crossRepo, log, symbol) {
+  const { allChunks, hitLimit } = await scanChunks(vectorDB, crossRepo, log);
+  log(`Scanning ${allChunks.length} chunks for imports...`);
+  const normalizePathCached = createPathNormalizer();
+  const normalizedTarget = normalizePathCached(filepath);
+  const importIndex = buildImportIndex(allChunks, normalizePathCached);
+  const dependentChunks = findDependentChunks(importIndex, normalizedTarget);
+  const chunksByFile = groupChunksByFile(dependentChunks);
   const fileComplexities = calculateFileComplexities(chunksByFile);
   const complexityMetrics = calculateOverallComplexityMetrics(fileComplexities);
-  const uniqueFiles = Array.from(chunksByFile.keys()).map((filepath2) => ({
-    filepath: filepath2,
-    isTestFile: isTestFile(filepath2)
-  }));
+  const { dependents, totalUsageCount } = buildDependentsList(
+    chunksByFile,
+    symbol,
+    normalizedTarget,
+    normalizePathCached,
+    allChunks,
+    filepath,
+    log
+  );
+  dependents.sort((a, b) => {
+    if (a.isTestFile === b.isTestFile) return 0;
+    return a.isTestFile ? 1 : -1;
+  });
+  const testDependentCount = dependents.filter((f) => f.isTestFile).length;
+  const productionDependentCount = dependents.length - testDependentCount;
   return {
-    dependents: uniqueFiles,
+    dependents,
+    productionDependentCount,
+    testDependentCount,
     chunksByFile,
     fileComplexities,
     complexityMetrics,
     hitLimit,
-    allChunks
+    allChunks,
+    totalUsageCount
   };
 }
 function buildImportIndex(allChunks, normalizePathCached) {
   const importIndex = /* @__PURE__ */ new Map();
+  const addToIndex = (importPath, chunk) => {
+    const normalizedImport = normalizePathCached(importPath);
+    if (!importIndex.has(normalizedImport)) {
+      importIndex.set(normalizedImport, []);
+    }
+    importIndex.get(normalizedImport).push(chunk);
+  };
   for (const chunk of allChunks) {
     const imports = chunk.metadata.imports || [];
     for (const imp of imports) {
-      const normalizedImport = normalizePathCached(imp);
-      if (!importIndex.has(normalizedImport)) {
-        importIndex.set(normalizedImport, []);
+      addToIndex(imp, chunk);
+    }
+    const importedSymbols = chunk.metadata.importedSymbols;
+    if (importedSymbols && typeof importedSymbols === "object") {
+      for (const modulePath of Object.keys(importedSymbols)) {
+        addToIndex(modulePath, chunk);
       }
-      importIndex.get(normalizedImport).push(chunk);
     }
   }
   return importIndex;
@@ -9079,14 +9187,15 @@ function calculateComplexityRiskBoost(avgComplexity, maxComplexity) {
   }
   return "low";
 }
-function calculateRiskLevel(dependentCount, complexityRiskBoost) {
+function calculateRiskLevel(dependentCount, complexityRiskBoost, productionDependentCount) {
   const DEPENDENT_COUNT_THRESHOLDS = {
     LOW: 5,
     MEDIUM: 15,
     HIGH: 30
   };
   const RISK_ORDER = { low: 0, medium: 1, high: 2, critical: 3 };
-  let riskLevel = dependentCount === 0 ? "low" : dependentCount <= DEPENDENT_COUNT_THRESHOLDS.LOW ? "low" : dependentCount <= DEPENDENT_COUNT_THRESHOLDS.MEDIUM ? "medium" : dependentCount <= DEPENDENT_COUNT_THRESHOLDS.HIGH ? "high" : "critical";
+  const effectiveCount = productionDependentCount ?? dependentCount;
+  let riskLevel = effectiveCount === 0 ? "low" : effectiveCount <= DEPENDENT_COUNT_THRESHOLDS.LOW ? "low" : effectiveCount <= DEPENDENT_COUNT_THRESHOLDS.MEDIUM ? "medium" : effectiveCount <= DEPENDENT_COUNT_THRESHOLDS.HIGH ? "high" : "critical";
   if (RISK_ORDER[complexityRiskBoost] > RISK_ORDER[riskLevel]) {
     riskLevel = complexityRiskBoost;
   }
@@ -9118,45 +9227,167 @@ function groupDependentsByRepo(dependents, chunks) {
   }
   return grouped;
 }
+function findSymbolUsages(chunksByFile, targetSymbol, normalizedTarget, normalizePathCached) {
+  const dependents = [];
+  let totalUsageCount = 0;
+  for (const [filepath, chunks] of chunksByFile.entries()) {
+    if (!fileImportsSymbol(chunks, targetSymbol, normalizedTarget, normalizePathCached)) {
+      continue;
+    }
+    const usages = extractSymbolUsagesFromChunks(chunks, targetSymbol);
+    dependents.push({
+      filepath,
+      isTestFile: isTestFile(filepath),
+      usages: usages.length > 0 ? usages : void 0
+    });
+    totalUsageCount += usages.length;
+  }
+  return { dependents, totalUsageCount };
+}
+function fileImportsSymbol(chunks, targetSymbol, normalizedTarget, normalizePathCached) {
+  return chunks.some((chunk) => {
+    const importedSymbols = chunk.metadata.importedSymbols;
+    if (!importedSymbols) return false;
+    for (const [importPath, symbols] of Object.entries(importedSymbols)) {
+      const normalizedImport = normalizePathCached(importPath);
+      if (matchesFile(normalizedImport, normalizedTarget)) {
+        if (symbols.includes(targetSymbol)) return true;
+        if (symbols.some((s) => s.startsWith("* as "))) return true;
+      }
+    }
+    return false;
+  });
+}
+function extractSymbolUsagesFromChunks(chunks, targetSymbol) {
+  const usages = [];
+  for (const chunk of chunks) {
+    const callSites = chunk.metadata.callSites;
+    if (!callSites) continue;
+    const lines = chunk.content.split("\n");
+    for (const call of callSites) {
+      if (call.symbol === targetSymbol) {
+        usages.push({
+          callerSymbol: chunk.metadata.symbolName || "unknown",
+          line: call.line,
+          snippet: extractSnippet(lines, call.line, chunk.metadata.startLine, targetSymbol)
+        });
+      }
+    }
+  }
+  return usages;
+}
+function extractSnippet(lines, callLine, startLine, symbolName) {
+  const lineIndex = callLine - startLine;
+  const placeholder = `${symbolName}(...)`;
+  if (lineIndex < 0 || lineIndex >= lines.length) {
+    return placeholder;
+  }
+  const directLine = lines[lineIndex].trim();
+  if (directLine) {
+    return directLine;
+  }
+  const searchRadius = 5;
+  for (let i = lineIndex - 1; i >= Math.max(0, lineIndex - searchRadius); i--) {
+    const candidate = lines[i].trim();
+    if (candidate) {
+      return candidate;
+    }
+  }
+  for (let i = lineIndex + 1; i < Math.min(lines.length, lineIndex + searchRadius + 1); i++) {
+    const candidate = lines[i].trim();
+    if (candidate) {
+      return candidate;
+    }
+  }
+  return placeholder;
+}
 
 // src/mcp/handlers/get-dependents.ts
+function checkCrossRepoFallback(crossRepo, vectorDB) {
+  return Boolean(crossRepo && !(vectorDB instanceof QdrantDB3));
+}
+function buildNotes(crossRepoFallback, hitLimit) {
+  const notes = [];
+  if (crossRepoFallback) {
+    notes.push("Cross-repo search requires Qdrant backend. Fell back to single-repo search.");
+  }
+  if (hitLimit) {
+    notes.push("Scanned 10,000 chunks (limit reached). Results may be incomplete.");
+  }
+  return notes;
+}
+function logRiskAssessment(analysis, riskLevel, symbol, log) {
+  const prodTest = `(${analysis.productionDependentCount} prod, ${analysis.testDependentCount} test)`;
+  if (symbol && analysis.totalUsageCount !== void 0) {
+    if (analysis.totalUsageCount > 0) {
+      log(
+        `Found ${analysis.totalUsageCount} tracked call sites across ${analysis.dependents.length} files ${prodTest} - risk: ${riskLevel}`
+      );
+    } else {
+      log(
+        `Found ${analysis.dependents.length} files importing '${symbol}' ${prodTest} - risk: ${riskLevel} (Note: Call site tracking unavailable for these chunks)`
+      );
+    }
+  } else {
+    log(
+      `Found ${analysis.dependents.length} dependents ${prodTest} - risk: ${riskLevel}`
+    );
+  }
+}
+function buildDependentsResponse(analysis, args, riskLevel, indexInfo, notes, crossRepo, vectorDB) {
+  const { symbol, filepath } = args;
+  const response = {
+    indexInfo,
+    filepath,
+    dependentCount: analysis.dependents.length,
+    productionDependentCount: analysis.productionDependentCount,
+    testDependentCount: analysis.testDependentCount,
+    riskLevel,
+    dependents: analysis.dependents,
+    complexityMetrics: analysis.complexityMetrics
+  };
+  if (symbol) {
+    response.symbol = symbol;
+  }
+  if (analysis.totalUsageCount !== void 0) {
+    response.totalUsageCount = analysis.totalUsageCount;
+  }
+  if (notes.length > 0) {
+    response.note = notes.join(" ");
+  }
+  if (crossRepo && vectorDB instanceof QdrantDB3) {
+    response.groupedByRepo = groupDependentsByRepo(analysis.dependents, analysis.allChunks);
+  }
+  return response;
+}
 async function handleGetDependents(args, ctx) {
   const { vectorDB, log, checkAndReconnect, getIndexMetadata } = ctx;
   return await wrapToolHandler(
     GetDependentsSchema,
     async (validatedArgs) => {
-      const { crossRepo, filepath } = validatedArgs;
-      log(`Finding dependents of: ${filepath}${crossRepo ? " (cross-repo)" : ""}`);
+      const { crossRepo, filepath, symbol } = validatedArgs;
+      const symbolSuffix = symbol ? ` (symbol: ${symbol})` : "";
+      const crossRepoSuffix = crossRepo ? " (cross-repo)" : "";
+      log(`Finding dependents of: ${filepath}${symbolSuffix}${crossRepoSuffix}`);
       await checkAndReconnect();
-      const analysis = await findDependents(vectorDB, filepath, crossRepo ?? false, log);
+      const analysis = await findDependents(vectorDB, filepath, crossRepo ?? false, log, symbol);
       const riskLevel = calculateRiskLevel(
         analysis.dependents.length,
-        analysis.complexityMetrics.complexityRiskBoost
+        analysis.complexityMetrics.complexityRiskBoost,
+        analysis.productionDependentCount
       );
-      log(
-        `Found ${analysis.dependents.length} dependent files (risk: ${riskLevel}${analysis.complexityMetrics.filesWithComplexityData > 0 ? ", complexity-boosted" : ""})`
-      );
-      const notes = [];
-      const crossRepoFallback = crossRepo && !(vectorDB instanceof QdrantDB3);
-      if (crossRepoFallback) {
-        notes.push("Cross-repo search requires Qdrant backend. Fell back to single-repo search.");
-      }
-      if (analysis.hitLimit) {
-        notes.push("Scanned 10,000 chunks (limit reached). Results may be incomplete.");
-      }
-      const response = {
-        indexInfo: getIndexMetadata(),
-        filepath: validatedArgs.filepath,
-        dependentCount: analysis.dependents.length,
+      logRiskAssessment(analysis, riskLevel, symbol, log);
+      const crossRepoFallback = checkCrossRepoFallback(crossRepo, vectorDB);
+      const notes = buildNotes(crossRepoFallback, analysis.hitLimit);
+      return buildDependentsResponse(
+        analysis,
+        validatedArgs,
         riskLevel,
-        dependents: analysis.dependents,
-        complexityMetrics: analysis.complexityMetrics,
-        ...notes.length > 0 && { note: notes.join(" ") }
-      };
-      if (crossRepo && vectorDB instanceof QdrantDB3) {
-        response.groupedByRepo = groupDependentsByRepo(analysis.dependents, analysis.allChunks);
-      }
-      return response;
+        getIndexMetadata(),
+        notes,
+        crossRepo,
+        vectorDB
+      );
     }
   )(args);
 }