@esankhan3/code-search-mcp 0.0.1

package/dist/core/git-diff.js

@@ -0,0 +1,160 @@
+import { execSync } from "node:child_process";
+import { extname } from "node:path";
+const SOURCE_EXTS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".go",
+  ".py",
+  ".rs",
+  ".java",
+  ".php",
+  ".rb",
+  ".swift",
+  ".kt",
+  ".cs",
+  ".scala",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".yaml",
+  ".yml",
+  ".json",
+  ".toml",
+  ".xml",
+  ".sql",
+  ".graphql",
+  ".proto",
+  ".md",
+  ".txt"
+]);
+function isSourceFile(filePath) {
+  return SOURCE_EXTS.has(extname(filePath).toLowerCase());
+}
+function parseNameStatus(output) {
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  const renamed = [];
+  if (!output) return { added, modified, deleted, renamed, fallbackToFull: false };
+  for (const line of output.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    const status = parts[0];
+    const filePath = parts[1];
+    if (!filePath || !status) continue;
+    if (!isSourceFile(filePath) && status[0] !== "R" && status[0] !== "C") continue;
+    switch (status[0]) {
+      case "A":
+        added.push(filePath);
+        break;
+      case "M":
+        modified.push(filePath);
+        break;
+      case "D":
+        deleted.push(filePath);
+        break;
+      case "R": {
+        const newPath = parts[2];
+        if (newPath) {
+          renamed.push({ from: filePath, to: newPath });
+          if (isSourceFile(filePath)) deleted.push(filePath);
+          if (isSourceFile(newPath)) added.push(newPath);
+        }
+        break;
+      }
+      case "C": {
+        const copyPath = parts[2];
+        if (copyPath && isSourceFile(copyPath)) added.push(copyPath);
+        break;
+      }
+    }
+  }
+  return { added, modified, deleted, renamed, fallbackToFull: false };
+}
+function mergeDiffs(a, b, extraAdded) {
+  const allAdded = /* @__PURE__ */ new Set([...a.added, ...b.added, ...extraAdded]);
+  const allModified = /* @__PURE__ */ new Set([...a.modified, ...b.modified]);
+  const allDeleted = /* @__PURE__ */ new Set([...a.deleted, ...b.deleted]);
+  const allRenamed = [...a.renamed, ...b.renamed];
+  for (const f of allAdded) allModified.delete(f);
+  for (const f of [...allAdded]) {
+    if (allDeleted.has(f)) {
+      allAdded.delete(f);
+      allDeleted.delete(f);
+      allModified.add(f);
+    }
+  }
+  return {
+    added: [...allAdded],
+    modified: [...allModified],
+    deleted: [...allDeleted],
+    renamed: allRenamed,
+    fallbackToFull: a.fallbackToFull || b.fallbackToFull
+  };
+}
+function getCommittedChanges(repoPath, sinceCommit) {
+  try {
+    const output = execSync(
+      `git diff --name-status ${sinceCommit}..HEAD`,
+      { cwd: repoPath, encoding: "utf-8", timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    return parseNameStatus(output);
+  } catch {
+    return { added: [], modified: [], deleted: [], renamed: [], fallbackToFull: true };
+  }
+}
+function getUncommittedChanges(repoPath) {
+  try {
+    const staged = execSync("git diff --name-status --cached", {
+      cwd: repoPath,
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const unstaged = execSync("git diff --name-status", {
+      cwd: repoPath,
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const untracked = execSync("git ls-files --others --exclude-standard", {
+      cwd: repoPath,
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const stagedDiff = parseNameStatus(staged);
+    const unstagedDiff = parseNameStatus(unstaged);
+    const untrackedFiles = untracked ? untracked.split("\n").filter((f) => f && isSourceFile(f)) : [];
+    return mergeDiffs(stagedDiff, unstagedDiff, untrackedFiles);
+  } catch {
+    return { added: [], modified: [], deleted: [], renamed: [], fallbackToFull: false };
+  }
+}
+function getAllChanges(repoPath, lastIndexedSha) {
+  if (!lastIndexedSha) {
+    return { added: [], modified: [], deleted: [], renamed: [], fallbackToFull: true };
+  }
+  const committed = getCommittedChanges(repoPath, lastIndexedSha);
+  if (committed.fallbackToFull) return committed;
+  const uncommitted = getUncommittedChanges(repoPath);
+  return mergeDiffs(committed, uncommitted, []);
+}
+function getChangedFilesList(diff) {
+  return [...diff.added, ...diff.modified];
+}
+function getDeletedFilesList(diff) {
+  return [...diff.deleted];
+}
+export {
+  getAllChanges,
+  getChangedFilesList,
+  getCommittedChanges,
+  getDeletedFilesList,
+  getUncommittedChanges
+};

package/dist/core/graph-metrics.js

@@ -0,0 +1,233 @@
+function isEntityNode(node) {
+  return node.type !== "module" && node.type !== "package";
+}
+function isContainsEdge(edge) {
+  return edge.type === "contains";
+}
+function deterministicSample(arr, n) {
+  if (arr.length <= n) return arr;
+  const step = arr.length / n;
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    result.push(arr[Math.floor(i * step)]);
+  }
+  return result;
+}
+function generateGraphQualityReport(graph) {
+  const { nodes, links: edges } = graph;
+  const edgesByType = {};
+  for (const edge of edges) {
+    const t = edge.type ?? "unknown";
+    edgesByType[t] = (edgesByType[t] ?? 0) + 1;
+  }
+  const edgesByConfidence = { high: 0, medium: 0, low: 0, unscored: 0 };
+  for (const edge of edges) {
+    const conf = edge.confidence;
+    if (conf == null) {
+      edgesByConfidence.unscored++;
+    } else if (conf > 0.8) {
+      edgesByConfidence.high++;
+    } else if (conf >= 0.5) {
+      edgesByConfidence.medium++;
+    } else {
+      edgesByConfidence.low++;
+    }
+  }
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  const fullAdj = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    outgoing.set(node.id, []);
+    incoming.set(node.id, []);
+    fullAdj.set(node.id, /* @__PURE__ */ new Set());
+  }
+  for (const edge of edges) {
+    let setA = fullAdj.get(edge.source);
+    if (!setA) {
+      setA = /* @__PURE__ */ new Set();
+      fullAdj.set(edge.source, setA);
+    }
+    setA.add(edge.target);
+    let setB = fullAdj.get(edge.target);
+    if (!setB) {
+      setB = /* @__PURE__ */ new Set();
+      fullAdj.set(edge.target, setB);
+    }
+    setB.add(edge.source);
+    if (!isContainsEdge(edge)) {
+      const out = outgoing.get(edge.source);
+      if (out) out.push(edge.target);
+      const inc = incoming.get(edge.target);
+      if (inc) inc.push(edge.source);
+    }
+  }
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeMap.set(node.id, node);
+  }
+  const entityNodes = nodes.filter(isEntityNode);
+  const orphanEntities = entityNodes.filter(
+    (n) => (outgoing.get(n.id)?.length ?? 0) === 0
+  );
+  const orphanEntityCount = orphanEntities.length;
+  const orphanEntityPercent = entityNodes.length > 0 ? Math.round(orphanEntityCount / entityNodes.length * 1e4) / 100 : 0;
+  let totalOutDegree = 0;
+  for (const n of entityNodes) {
+    totalOutDegree += outgoing.get(n.id)?.length ?? 0;
+  }
+  const avgOutDegreeEntities = entityNodes.length > 0 ? Math.round(totalOutDegree / entityNodes.length * 100) / 100 : 0;
+  const seeds = deterministicSample(entityNodes, 20);
+  let sumDepth1 = 0;
+  let sumDepth2 = 0;
+  let sumEntityDepth2 = 0;
+  for (const seed of seeds) {
+    const visited = /* @__PURE__ */ new Set([seed.id]);
+    let frontier = [seed.id];
+    const depth1Frontier = [];
+    for (const nid of frontier) {
+      for (const neighbor of outgoing.get(nid) ?? []) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          depth1Frontier.push(neighbor);
+        }
+      }
+      for (const neighbor of incoming.get(nid) ?? []) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          depth1Frontier.push(neighbor);
+        }
+      }
+    }
+    sumDepth1 += depth1Frontier.length;
+    frontier = depth1Frontier;
+    const depth2New = [];
+    for (const nid of frontier) {
+      for (const neighbor of outgoing.get(nid) ?? []) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          depth2New.push(neighbor);
+        }
+      }
+      for (const neighbor of incoming.get(nid) ?? []) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          depth2New.push(neighbor);
+        }
+      }
+    }
+    const totalDepth2 = depth1Frontier.length + depth2New.length;
+    sumDepth2 += totalDepth2;
+    let entityCount = 0;
+    for (const nid of [...depth1Frontier, ...depth2New]) {
+      const node = nodeMap.get(nid);
+      if (node && isEntityNode(node)) entityCount++;
+    }
+    sumEntityDepth2 += entityCount;
+  }
+  const sampleSize = seeds.length;
+  const bfsReachability = {
+    sampleSize,
+    avgReachedDepth1: sampleSize > 0 ? Math.round(sumDepth1 / sampleSize * 100) / 100 : 0,
+    avgReachedDepth2: sampleSize > 0 ? Math.round(sumDepth2 / sampleSize * 100) / 100 : 0,
+    avgEntityReachedDepth2: sampleSize > 0 ? Math.round(sumEntityDepth2 / sampleSize * 100) / 100 : 0
+  };
+  const degreeList = [];
+  for (const node of nodes) {
+    const deg = fullAdj.get(node.id)?.size ?? 0;
+    degreeList.push({ id: node.id, degree: deg, type: node.type ?? "unknown" });
+  }
+  degreeList.sort((a, b) => b.degree - a.degree);
+  const hubNodes = degreeList.slice(0, 10);
+  const componentVisited = /* @__PURE__ */ new Set();
+  const componentSizes = [];
+  for (const node of nodes) {
+    if (componentVisited.has(node.id)) continue;
+    let size = 0;
+    const queue = [node.id];
+    componentVisited.add(node.id);
+    while (queue.length > 0) {
+      const current = queue.pop();
+      size++;
+      for (const neighbor of fullAdj.get(current) ?? []) {
+        if (!componentVisited.has(neighbor)) {
+          componentVisited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+    componentSizes.push(size);
+  }
+  const connectedComponents = componentSizes.length;
+  const largestComponent = componentSizes.length > 0 ? Math.max(...componentSizes) : 0;
+  const largestComponentPercent = nodes.length > 0 ? Math.round(largestComponent / nodes.length * 1e4) / 100 : 0;
+  return {
+    nodeCount: nodes.length,
+    edgeCount: edges.length,
+    edgesByType,
+    edgesByConfidence,
+    orphanEntityCount,
+    orphanEntityPercent,
+    avgOutDegreeEntities,
+    bfsReachability,
+    hubNodes,
+    connectedComponents,
+    largestComponentPercent
+  };
+}
+function formatQualityReport(report) {
+  const lines = [];
+  lines.push("# Graph Quality Report");
+  lines.push("");
+  lines.push("## Overview");
+  lines.push("");
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Nodes | ${report.nodeCount} |`);
+  lines.push(`| Edges | ${report.edgeCount} |`);
+  lines.push(`| Connected components | ${report.connectedComponents} |`);
+  lines.push(`| Largest component | ${report.largestComponentPercent}% of nodes |`);
+  lines.push(`| Orphan entities | ${report.orphanEntityCount} (${report.orphanEntityPercent}%) |`);
+  lines.push(`| Avg out-degree (entities) | ${report.avgOutDegreeEntities} |`);
+  lines.push("");
+  lines.push("## Edges by Type");
+  lines.push("");
+  lines.push("| Type | Count |");
+  lines.push("|------|-------|");
+  const sortedTypes = Object.entries(report.edgesByType).sort((a, b) => b[1] - a[1]);
+  for (const [type, count] of sortedTypes) {
+    lines.push(`| ${type} | ${count} |`);
+  }
+  lines.push("");
+  lines.push("## Edges by Confidence");
+  lines.push("");
+  lines.push("| Bucket | Count |");
+  lines.push("|--------|-------|");
+  lines.push(`| High (>0.8) | ${report.edgesByConfidence.high} |`);
+  lines.push(`| Medium (0.5-0.8) | ${report.edgesByConfidence.medium} |`);
+  lines.push(`| Low (<0.5) | ${report.edgesByConfidence.low} |`);
+  lines.push(`| Unscored | ${report.edgesByConfidence.unscored} |`);
+  lines.push("");
+  lines.push("## BFS Reachability (non-contains edges)");
+  lines.push("");
+  lines.push(`Sample size: ${report.bfsReachability.sampleSize} entity nodes`);
+  lines.push("");
+  lines.push("| Metric | Value |");
+  lines.push("|--------|-------|");
+  lines.push(`| Avg reached at depth 1 | ${report.bfsReachability.avgReachedDepth1} |`);
+  lines.push(`| Avg reached at depth 2 | ${report.bfsReachability.avgReachedDepth2} |`);
+  lines.push(`| Avg entities reached at depth 2 | ${report.bfsReachability.avgEntityReachedDepth2} |`);
+  lines.push("");
+  lines.push("## Hub Nodes (top 10 by degree)");
+  lines.push("");
+  lines.push("| Node | Degree | Type |");
+  lines.push("|------|--------|------|");
+  for (const hub of report.hubNodes) {
+    lines.push(`| ${hub.id} | ${hub.degree} | ${hub.type} |`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+export {
+  formatQualityReport,
+  generateGraphQualityReport
+};