@esankhan3/code-search-mcp 0.0.2 → 0.1.0

package/dist/core/project-graph-builder.js

@@ -1,202 +0,0 @@
-let _Graph;
-let _louvain;
-async function ensureGraphology() {
-  if (_Graph) return;
-  const graphMod = await import("graphology");
-  _Graph = graphMod.default ?? graphMod;
-  const louvainMod = await import("graphology-communities-louvain");
-  _louvain = louvainMod.default ?? louvainMod;
-}
-function getGraphClass() {
-  if (!_Graph) throw new Error("Call ensureGraphology() before using graph operations");
-  return _Graph;
-}
-class ProjectGraphBuilder {
-  graph;
-  constructor() {
-    this.graph = null;
-  }
-  /** Must be called before using the builder */
-  async init() {
-    await ensureGraphology();
-    const G = getGraphClass();
-    this.graph = new G({ type: "directed", multi: true });
-  }
-  /** Expose the underlying graph for query functions */
-  getGraph() {
-    return this.graph;
-  }
-  /** Load a per-repo graph.json from Graphify and merge into the project graph.
-   * Namespace all nodes as "repoName::originalId" to avoid collisions. */
-  addRepoGraph(repoName, graphJson) {
-    for (const node of graphJson.nodes) {
-      const nsId = `${repoName}::${node.id}`;
-      if (!this.graph.hasNode(nsId)) {
-        this.graph.addNode(nsId, {
-          repo: repoName,
-          label: node.label ?? node.id,
-          community: node.community,
-          type: node.type,
-          file: node.file
-        });
-      }
-    }
-    for (const edge of graphJson.links) {
-      const src = `${repoName}::${edge.source}`;
-      const tgt = `${repoName}::${edge.target}`;
-      if (this.graph.hasNode(src) && this.graph.hasNode(tgt)) {
-        this.graph.addEdge(src, tgt, {
-          type: edge.type ?? "depends",
-          confidence: edge.confidence ?? 0.8
-        });
-      }
-    }
-  }
-  /** Add cross-repo edges detected by the cross-repo detector */
-  addCrossRepoEdges(edges) {
-    for (const edge of edges) {
-      const srcId = `${edge.sourceRepo}::${edge.sourceNode}`;
-      const tgtId = `${edge.targetRepo}::${edge.targetNode}`;
-      if (!this.graph.hasNode(srcId)) {
-        this.graph.addNode(srcId, { repo: edge.sourceRepo, label: edge.sourceNode, type: "external" });
-      }
-      if (!this.graph.hasNode(tgtId)) {
-        this.graph.addNode(tgtId, { repo: edge.targetRepo, label: edge.targetNode, type: "external" });
-      }
-      this.graph.addEdge(srcId, tgtId, {
-        type: edge.edgeType,
-        evidence: edge.evidence,
-        confidence: edge.confidence,
-        crossRepo: true
-      });
-    }
-  }
-  /** Run Louvain community detection on the merged graph */
-  detectCommunities() {
-    if (this.graph.order === 0) return /* @__PURE__ */ new Map();
-    const G = getGraphClass();
-    const undirected = new G({ type: "undirected" });
-    this.graph.forEachNode((node, attrs) => {
-      undirected.mergeNode(node, attrs);
-    });
-    this.graph.forEachEdge((_edge, attrs, src, tgt) => {
-      undirected.mergeEdge(src, tgt, attrs);
-    });
-    const communities = _louvain(undirected);
-    for (const [node, community] of Object.entries(communities)) {
-      if (this.graph.hasNode(node)) {
-        this.graph.setNodeAttribute(node, "systemCommunity", community);
-      }
-    }
-    return new Map(Object.entries(communities).map(([k, v]) => [k, v]));
-  }
-  /** Confidence-weighted BFS impact analysis from entry nodes.
-   *  Only follows edges with confidence >= minConfidence.
-   *  Sorts neighbors by confidence so high-quality paths are explored first. */
-  impactAnalysis(entryNodes, maxDepth = 3, opts) {
-    const minConf = opts?.minConfidence ?? 0;
-    const visited = /* @__PURE__ */ new Set();
-    let frontier = entryNodes.filter((n) => this.graph.hasNode(n));
-    for (let depth = 0; depth < maxDepth && frontier.length > 0; depth++) {
-      const nextFrontier = [];
-      for (const node of frontier) {
-        if (visited.has(node)) continue;
-        visited.add(node);
-        this.graph.forEachOutEdge(node, (_edge, attrs, _src, tgt) => {
-          const conf = attrs.confidence ?? 0.8;
-          if (conf >= minConf && !visited.has(tgt)) {
-            nextFrontier.push({ node: tgt, confidence: conf });
-          }
-        });
-      }
-      nextFrontier.sort((a, b) => b.confidence - a.confidence);
-      frontier = nextFrontier.map((f) => f.node);
-    }
-    return [...visited];
-  }
-  /** Get node type for a given node ID */
-  getNodeType(nodeId) {
-    if (!this.graph.hasNode(nodeId)) return null;
-    return this.graph.getNodeAttribute(nodeId, "type") ?? null;
-  }
-  /** Get highest-degree nodes (architectural hotspots) */
-  getHotspots(topN = 20) {
-    const nodes = [];
-    this.graph.forEachNode((node, attrs) => {
-      nodes.push({ node, degree: this.graph.degree(node), repo: attrs.repo ?? "" });
-    });
-    nodes.sort((a, b) => b.degree - a.degree);
-    return nodes.slice(0, topN);
-  }
-  /** Get cross-repo edges */
-  getCrossRepoEdges() {
-    const edges = [];
-    this.graph.forEachEdge((_edge, attrs, src, tgt) => {
-      if (attrs.crossRepo) {
-        edges.push({ source: src, target: tgt, type: attrs.type, evidence: attrs.evidence ?? "" });
-      }
-    });
-    return edges;
-  }
-  /** Export full graph as JSON */
-  exportJson() {
-    return this.graph.export();
-  }
-  /** Import from previously saved JSON */
-  async importJson(data) {
-    if (!this.graph) await this.init();
-    this.graph.import(data);
-  }
-  /** Get node count */
-  get nodeCount() {
-    return this.graph.order;
-  }
-  /** Get edge count */
-  get edgeCount() {
-    return this.graph.size;
-  }
-  /** Export compact summary for agent prompt injection */
-  exportForPrompt(maxChars = 5e3) {
-    const sections = [];
-    sections.push("## Project Architecture Graph\n");
-    const repoNodes = /* @__PURE__ */ new Map();
-    this.graph.forEachNode((_, attrs) => {
-      const repo = attrs.repo ?? "unknown";
-      repoNodes.set(repo, (repoNodes.get(repo) ?? 0) + 1);
-    });
-    sections.push("### Repositories");
-    for (const [repo, count] of repoNodes) {
-      sections.push(`- **${repo}**: ${count} nodes`);
-    }
-    const packageNodes = [];
-    this.graph.forEachNode((node, attrs) => {
-      if (attrs.type === "package") packageNodes.push({ node, repo: attrs.repo });
-    });
-    if (packageNodes.length > 0) {
-      sections.push("\n### Workspace Packages");
-      for (const p of packageNodes) {
-        sections.push(`- **${p.node}** (${p.repo})`);
-      }
-    }
-    const crossEdges = this.getCrossRepoEdges();
-    if (crossEdges.length > 0) {
-      sections.push("\n### Cross-Repo Connections");
-      for (const edge of crossEdges.slice(0, 20)) {
-        sections.push(`- ${edge.source} \u2192 ${edge.target} (${edge.type}: ${edge.evidence})`);
-      }
-    }
-    const hotspots = this.getHotspots(10);
-    if (hotspots.length > 0) {
-      sections.push("\n### Architectural Hotspots");
-      for (const h of hotspots) {
-        sections.push(`- **${h.node}** (${h.repo}, degree: ${h.degree})`);
-      }
-    }
-    let result = sections.join("\n");
-    if (result.length > maxChars) result = result.slice(0, maxChars) + "\n[...]";
-    return result;
-  }
-}
-export {
-  ProjectGraphBuilder
-};

package/dist/core/query-classifier.js

@@ -1,144 +0,0 @@
-const CAMEL_CASE_RE = /[a-z][A-Z]/;
-const SNAKE_CASE_RE = /[a-z]_[a-z]/;
-const PASCAL_CASE_RE = /^[A-Z][a-z]+[A-Z]/;
-const DOT_PATH_RE = /[a-zA-Z]\.[a-zA-Z]/;
-const FILE_PATH_RE = /[/\\].*\.\w{1,5}$/;
-const FILE_EXT_RE = /\.\w{1,5}$/;
-const PATH_SEPARATOR_RE = /[/\\]/;
-const HEX_CODE_RE = /0x[A-Fa-f0-9]+/;
-const ERROR_PREFIX_RE = /\bERR_\w+/;
-const NUMERIC_ERROR_RE = /\bE\d{4,}/;
-const HTTP_STATUS_RE = /\b[1-5]\d{2}\b/;
-const QUESTION_WORDS = /* @__PURE__ */ new Set([
-  "how",
-  "what",
-  "where",
-  "why",
-  "when",
-  "does",
-  "can",
-  "is",
-  "should",
-  "which",
-  "who",
-  "explain",
-  "describe",
-  "show"
-]);
-const WEIGHTS = {
-  identifier: { vector: 0.2, bm25: 0.6, graph: 0.2 },
-  path: { vector: 0.1, bm25: 0.7, graph: 0.2 },
-  "error-code": { vector: 0.1, bm25: 0.7, graph: 0.2 },
-  "natural-language": { vector: 0.6, bm25: 0.2, graph: 0.2 },
-  mixed: { vector: 0.4, bm25: 0.35, graph: 0.25 }
-};
-function classifyQuery(query) {
-  const trimmed = query.trim();
-  if (trimmed.length === 0) {
-    return {
-      type: "natural-language",
-      weights: { ...WEIGHTS["natural-language"] },
-      shouldUseTrigram: false,
-      explanation: "Empty query treated as natural language"
-    };
-  }
-  const words = trimmed.split(/\s+/);
-  const wordCount = words.length;
-  const firstWordLower = words[0].toLowerCase();
-  if (PATH_SEPARATOR_RE.test(trimmed) && FILE_EXT_RE.test(trimmed)) {
-    return {
-      type: "path",
-      weights: { ...WEIGHTS.path },
-      shouldUseTrigram: true,
-      explanation: `File path detected: contains path separator and file extension`
-    };
-  }
-  const hasHttpStatus = wordCount <= 3 && HTTP_STATUS_RE.test(trimmed);
-  if (HEX_CODE_RE.test(trimmed) || ERROR_PREFIX_RE.test(trimmed) || NUMERIC_ERROR_RE.test(trimmed) || hasHttpStatus) {
-    return {
-      type: "error-code",
-      weights: { ...WEIGHTS["error-code"] },
-      shouldUseTrigram: true,
-      explanation: `Error code pattern detected in query`
-    };
-  }
-  const hasCodeIdentifier = CAMEL_CASE_RE.test(trimmed) || SNAKE_CASE_RE.test(trimmed) || PASCAL_CASE_RE.test(trimmed) || DOT_PATH_RE.test(trimmed);
-  const hasQuestionWord = QUESTION_WORDS.has(firstWordLower);
-  const isLongPhrase = wordCount > 4;
-  const hasNaturalLanguageSignals = hasQuestionWord || isLongPhrase;
-  if (hasCodeIdentifier && hasNaturalLanguageSignals) {
-    return {
-      type: "mixed",
-      weights: { ...WEIGHTS.mixed },
-      shouldUseTrigram: true,
-      explanation: `Mixed query: contains code identifiers and natural language`
-    };
-  }
-  if (hasCodeIdentifier || wordCount <= 2 && !hasNaturalLanguageSignals) {
-    return {
-      type: "identifier",
-      weights: { ...WEIGHTS.identifier },
-      shouldUseTrigram: true,
-      explanation: `Identifier query: ${hasCodeIdentifier ? "code naming convention detected" : "short query without natural language signals"}`
-    };
-  }
-  return {
-    type: "natural-language",
-    weights: { ...WEIGHTS["natural-language"] },
-    shouldUseTrigram: false,
-    explanation: `Natural language query: ${hasQuestionWord ? "starts with question word" : `${wordCount} words without code patterns`}`
-  };
-}
-function routeQueryToRepos(query, profiles, opts) {
-  if (profiles.length === 0) return [];
-  const queryTokens = tokenize(query);
-  if (queryTokens.length === 0) return profiles.map((p) => p.name);
-  const scored = profiles.map((profile) => {
-    const profileTokens = /* @__PURE__ */ new Set([
-      ...tokenize(profile.name),
-      ...tokenize(profile.domain),
-      ...tokenize(profile.description),
-      ...profile.technologies.flatMap((t) => tokenize(t))
-    ]);
-    let score = 0;
-    for (const token of queryTokens) {
-      if (profileTokens.has(token)) {
-        score += 1;
-      }
-      for (const pt of Array.from(profileTokens)) {
-        if (pt !== token && pt.includes(token) && token.length >= 3) {
-          score += 0.5;
-        }
-      }
-    }
-    return { name: profile.name, score: score / queryTokens.length };
-  });
-  scored.sort((a, b) => b.score - a.score);
-  const maxRepos = opts?.maxRepos;
-  const topScore = scored[0].score;
-  if (topScore < 0.1) {
-    return profiles.map((p) => p.name);
-  }
-  const threshold = topScore * 0.3;
-  let relevant = scored.filter((s) => s.score >= threshold);
-  if (maxRepos && relevant.length > maxRepos) {
-    relevant = relevant.slice(0, maxRepos);
-  }
-  if (!maxRepos && profiles.length > 10) {
-    const cap = Math.ceil(profiles.length * 0.6);
-    if (relevant.length > cap) {
-      relevant = relevant.slice(0, cap);
-    }
-  }
-  if (relevant.length === 0) {
-    return profiles.map((p) => p.name);
-  }
-  return relevant.map((r) => r.name);
-}
-function tokenize(text) {
-  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 2);
-}
-export {
-  classifyQuery,
-  routeQueryToRepos
-};

package/dist/core/query-router.js

@@ -1,210 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { getKnowledgeBasePath } from "./config.js";
-function profileToSearchText(profile) {
-  const parts = [
-    `Repository: ${profile.name}`,
-    `Role: ${profile.role}`,
-    `Domain: ${profile.domain}`,
-    `Description: ${profile.description}`,
-    `Technologies: ${profile.technologies.join(", ")}`
-  ];
-  if (profile.exposes.length > 0) {
-    parts.push(
-      `Exposes: ${profile.exposes.map((e) => `${e.type}:${e.identifier}`).join(", ")}`
-    );
-  }
-  if (profile.consumes.length > 0) {
-    parts.push(
-      `Consumes: ${profile.consumes.map((c) => `${c.type}:${c.identifier}`).join(", ")}`
-    );
-  }
-  return parts.join("\n");
-}
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  return dot / (Math.sqrt(normA) * Math.sqrt(normB) + 1e-10);
-}
-async function embedProfiles(profiles, embedder) {
-  if (profiles.length === 0) return [];
-  const texts = profiles.map(profileToSearchText);
-  const embeddings = await embedder.embed(texts);
-  return profiles.map((profile, i) => ({
-    repoName: profile.name,
-    embedding: embeddings[i],
-    textUsed: texts[i]
-  }));
-}
-async function routeQuery(query, profileEmbeddings, embedder, opts) {
-  const minRepos = opts?.minRepos ?? 3;
-  const maxFraction = opts?.maxFraction ?? 0.6;
-  const total = profileEmbeddings.length;
-  if (total <= 10) {
-    const scores2 = /* @__PURE__ */ new Map();
-    for (const pe of profileEmbeddings) {
-      scores2.set(pe.repoName, 1);
-    }
-    return {
-      repos: profileEmbeddings.map((pe) => pe.repoName),
-      scores: scores2,
-      strategy: "all"
-    };
-  }
-  const queryEmbedding = await embedder.embedSingle(query);
-  const scored = profileEmbeddings.map(
-    (pe) => ({
-      repoName: pe.repoName,
-      score: cosineSimilarity(queryEmbedding, pe.embedding)
-    })
-  );
-  scored.sort((a, b) => b.score - a.score);
-  const scores = scored.map((s) => s.score);
-  const mean = scores.reduce((sum, v) => sum + v, 0) / scores.length;
-  const variance = scores.reduce((sum, v) => sum + (v - mean) ** 2, 0) / scores.length;
-  const stddev = Math.sqrt(variance);
-  const threshold = mean + 0.5 * stddev;
-  let filtered = scored.filter((s) => s.score >= threshold);
-  if (filtered.length < minRepos) {
-    filtered = scored.slice(0, Math.min(minRepos, total));
-  }
-  const maxCount = Math.ceil(total * maxFraction);
-  if (filtered.length > maxCount) {
-    filtered = filtered.slice(0, maxCount);
-  }
-  if (filtered.length === 0) {
-    filtered = scored.slice(0, Math.min(5, total));
-  }
-  const resultScores = /* @__PURE__ */ new Map();
-  for (const s of filtered) {
-    resultScores.set(s.repoName, s.score);
-  }
-  return {
-    repos: filtered.map((s) => s.repoName),
-    scores: resultScores,
-    strategy: "filtered"
-  };
-}
-class QueryRouter {
-  profileEmbeddings = [];
-  embedder;
-  initialized = false;
-  constructor(embedder) {
-    this.embedder = embedder;
-  }
-  /**
-   * Initialize with profiles. Embeds all profiles (one-time cost).
-   */
-  async init(profiles) {
-    this.profileEmbeddings = await embedProfiles(profiles, this.embedder);
-    this.initialized = true;
-  }
-  /**
-   * Load cached embeddings from disk (skip re-embedding).
-   * Returns true if cache was loaded successfully.
-   */
-  loadCached(cachePath) {
-    const filePath = join(cachePath, "profile_embeddings.json");
-    if (!existsSync(filePath)) return false;
-    try {
-      const raw = readFileSync(filePath, "utf-8");
-      const data = JSON.parse(raw);
-      if (!Array.isArray(data) || data.length === 0) return false;
-      const first = data[0];
-      if (typeof first.repoName !== "string" || !Array.isArray(first.embedding) || typeof first.textUsed !== "string") {
-        return false;
-      }
-      this.profileEmbeddings = data;
-      this.initialized = true;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Save embeddings to disk for future use.
-   */
-  saveCached(cachePath) {
-    const filePath = join(cachePath, "profile_embeddings.json");
-    const dir = dirname(filePath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(filePath, JSON.stringify(this.profileEmbeddings, null, 2), "utf-8");
-  }
-  /**
-   * Route a query to relevant repos.
-   */
-  async route(query, opts) {
-    if (!this.initialized) {
-      return { repos: [], scores: /* @__PURE__ */ new Map(), strategy: "all" };
-    }
-    return routeQuery(query, this.profileEmbeddings, this.embedder, opts);
-  }
-  /**
-   * Get all repo names (for when routing is not needed).
-   */
-  getAllRepos() {
-    return this.profileEmbeddings.map((pe) => pe.repoName);
-  }
-  /**
-   * Check whether the router has been initialized.
-   */
-  isReady() {
-    return this.initialized;
-  }
-  /**
-   * Number of repos loaded.
-   */
-  get repoCount() {
-    return this.profileEmbeddings.length;
-  }
-}
-async function createQueryRouter(project, embedder) {
-  const kbPath = getKnowledgeBasePath(project);
-  if (!existsSync(kbPath)) return null;
-  const profiles = [];
-  let entries;
-  try {
-    entries = readdirSync(kbPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-  } catch {
-    return null;
-  }
-  for (const repoDir of entries) {
-    const profilePath = join(kbPath, repoDir, "profile.json");
-    if (!existsSync(profilePath)) continue;
-    try {
-      const raw = readFileSync(profilePath, "utf-8");
-      const profile = JSON.parse(raw);
-      if (profile.name && profile.role) {
-        profiles.push(profile);
-      }
-    } catch {
-    }
-  }
-  if (profiles.length === 0) return null;
-  const router = new QueryRouter(embedder);
-  if (router.loadCached(kbPath)) {
-    const cachedRepos = new Set(router.getAllRepos());
-    const currentRepos = new Set(profiles.map((p) => p.name));
-    const cacheValid = cachedRepos.size === currentRepos.size && Array.from(currentRepos).every((r) => cachedRepos.has(r));
-    if (cacheValid) {
-      return router;
-    }
-  }
-  await router.init(profiles);
-  router.saveCached(kbPath);
-  return router;
-}
-export {
-  QueryRouter,
-  createQueryRouter,
-  embedProfiles,
-  routeQuery
-};