@esankhan3/code-search-mcp 0.0.1 → 0.1.0

package/dist/core/reranker.js

@@ -1,218 +0,0 @@
-async function parallelMap(items, fn, concurrency) {
-  const results = new Array(items.length);
-  let nextIndex = 0;
-  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-    while (nextIndex < items.length) {
-      const i = nextIndex++;
-      results[i] = await fn(items[i], i);
-    }
-  });
-  await Promise.all(workers);
-  return results;
-}
-class OllamaReranker {
-  baseUrl;
-  model;
-  timeoutMs;
-  constructor(opts) {
-    this.baseUrl = opts?.baseUrl || process.env.OLLAMA_HOST || "http://localhost:11434";
-    this.model = opts?.model || process.env.RERANKER_MODEL || "qwen3:0.6b";
-    this.timeoutMs = opts?.timeoutMs ?? 3e4;
-  }
-  async scoreOne(query, doc, index) {
-    try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-      const response = await fetch(`${this.baseUrl}/api/chat`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          model: this.model,
-          messages: [
-            {
-              role: "user",
-              content: `Given a code search query, evaluate whether the following code document is relevant. Answer ONLY "yes" or "no", nothing else.
-
-Query: ${query}
-
-Document:
-${doc.slice(0, 1500)}
-
-Relevant? /no_think`
-            }
-          ],
-          stream: false,
-          options: { temperature: 0, num_predict: 10 }
-        }),
-        signal: controller.signal
-      });
-      clearTimeout(timer);
-      if (!response.ok) return { index, score: 0.5 };
-      const json = await response.json();
-      const raw = (json.message?.content ?? "").toLowerCase().trim();
-      const answer = raw.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
-      let score = 0.5;
-      if (answer.startsWith("yes")) score = 1;
-      else if (answer.startsWith("no")) score = 0;
-      else if (raw.includes("yes")) score = 0.8;
-      else if (raw.includes("no")) score = 0.2;
-      return { index, score };
-    } catch {
-      return { index, score: 0.5 };
-    }
-  }
-  async rerank(query, documents, topN) {
-    if (documents.length === 0) return [];
-    const scores = [];
-    for (let i = 0; i < documents.length; i++) {
-      const result = await this.scoreOne(query, documents[i], i);
-      scores.push(result);
-    }
-    scores.sort((a, b) => b.score - a.score);
-    return topN ? scores.slice(0, topN) : scores;
-  }
-}
-class CohereReranker {
-  async rerank(query, documents, topN) {
-    const apiKey = process.env.COHERE_API_KEY;
-    if (!apiKey) {
-      throw new Error("COHERE_API_KEY environment variable is not set");
-    }
-    const response = await fetch("https://api.cohere.com/v2/rerank", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        model: "rerank-v3.5",
-        query,
-        documents,
-        top_n: topN ?? documents.length
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Cohere rerank request failed (${response.status}): ${body}`);
-    }
-    const json = await response.json();
-    return json.results.map((r) => ({ index: r.index, score: r.relevance_score }));
-  }
-}
-class VoyageReranker {
-  async rerank(query, documents, topN) {
-    const apiKey = process.env.VOYAGE_API_KEY;
-    if (!apiKey) {
-      throw new Error("VOYAGE_API_KEY environment variable is not set");
-    }
-    const response = await fetch("https://api.voyageai.com/v1/rerank", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        model: "rerank-2",
-        query,
-        documents,
-        top_k: topN ?? documents.length
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Voyage rerank request failed (${response.status}): ${body}`);
-    }
-    const json = await response.json();
-    return json.data.map((r) => ({ index: r.index, score: r.relevance_score }));
-  }
-}
-class OpenAICompatibleReranker {
-  baseUrl;
-  model;
-  apiKey;
-  timeoutMs;
-  constructor(opts) {
-    this.baseUrl = opts?.baseUrl || process.env.CODE_SEARCH_RERANKER_BASE_URL || "";
-    this.model = opts?.model || process.env.CODE_SEARCH_RERANKER_MODEL || "";
-    this.apiKey = opts?.apiKey || process.env.CODE_SEARCH_RERANKER_API_KEY;
-    this.timeoutMs = opts?.timeoutMs ?? 3e4;
-    if (!this.baseUrl) throw new Error("Reranker base URL required. Set CODE_SEARCH_RERANKER_BASE_URL");
-    if (!this.model) throw new Error("Reranker model required. Set CODE_SEARCH_RERANKER_MODEL");
-  }
-  async scoreOne(query, doc, index) {
-    try {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-      const headers = { "Content-Type": "application/json" };
-      if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
-      const response = await fetch(`${this.baseUrl.replace(/\/$/, "")}/v1/chat/completions`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          model: this.model,
-          messages: [
-            {
-              role: "user",
-              content: `Given a code search query, evaluate whether the following code document is relevant. Answer ONLY "yes" or "no", nothing else.
-
-Query: ${query}
-
-Document:
-${doc.slice(0, 1500)}
-
-Relevant?`
-            }
-          ],
-          temperature: 0,
-          max_tokens: 5
-        }),
-        signal: controller.signal
-      });
-      clearTimeout(timer);
-      if (!response.ok) return { index, score: 0.5 };
-      const json = await response.json();
-      const answer = (json.choices?.[0]?.message?.content ?? "").toLowerCase().trim();
-      let score = 0.5;
-      if (answer.startsWith("yes")) score = 1;
-      else if (answer.startsWith("no")) score = 0;
-      else if (answer.includes("yes")) score = 0.8;
-      else if (answer.includes("no")) score = 0.2;
-      return { index, score };
-    } catch {
-      return { index, score: 0.5 };
-    }
-  }
-  async rerank(query, documents, topN) {
-    if (documents.length === 0) return [];
-    const scores = await parallelMap(
-      documents,
-      (doc, i) => this.scoreOne(query, doc, i),
-      5
-    );
-    scores.sort((a, b) => b.score - a.score);
-    return topN ? scores.slice(0, topN) : scores;
-  }
-}
-function createReranker(provider) {
-  switch (provider) {
-    case "ollama":
-      return new OllamaReranker();
-    case "cohere":
-      return new CohereReranker();
-    case "voyage":
-      return new VoyageReranker();
-    case "openai-compatible":
-    case "custom":
-      return new OpenAICompatibleReranker();
-    case "none":
-      return null;
-    default:
-      if (process.env.CODE_SEARCH_RERANKER_BASE_URL) {
-        return new OpenAICompatibleReranker();
-      }
-      return new OllamaReranker();
-  }
-}
-export {
-  createReranker
-};

package/dist/core/retriever.js

@@ -1,242 +0,0 @@
-import { classifyQuery } from "./query-classifier.js";
-const queryEmbeddingCache = /* @__PURE__ */ new Map();
-const CACHE_MAX_SIZE = 128;
-const CACHE_TTL_MS = 10 * 60 * 1e3;
-function getCachedEmbedding(query) {
-  const entry = queryEmbeddingCache.get(query);
-  if (!entry) return null;
-  if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
-    queryEmbeddingCache.delete(query);
-    return null;
-  }
-  return entry.embedding;
-}
-function cacheEmbedding(query, embedding) {
-  if (queryEmbeddingCache.size >= CACHE_MAX_SIZE) {
-    const oldest = queryEmbeddingCache.keys().next().value;
-    if (oldest !== void 0) queryEmbeddingCache.delete(oldest);
-  }
-  queryEmbeddingCache.set(query, { embedding, timestamp: Date.now() });
-}
-class HybridRetriever {
-  constructor(vectorStore, embedder, graph, config, reranker = null, queryRouter = null) {
-    this.config = config;
-    this.reranker = reranker;
-    this.queryRouter = queryRouter;
-    this.vectorStore = vectorStore;
-    this.embedder = embedder;
-    this.graph = graph;
-  }
-  // Expose for testing/debugging
-  vectorStore;
-  embedder;
-  graph;
-  async retrieve(query, opts) {
-    const maxChunks = opts?.maxChunks ?? this.config.maxChunks;
-    const maxTokens = opts?.maxTokens ?? this.config.maxTokens;
-    const mode = opts?.mode ?? "vector+bm25+graph";
-    const useVector = mode !== "bm25";
-    const useBm25 = mode === "bm25" || mode === "vector+bm25" || mode === "vector+bm25+graph";
-    const useGraph = mode === "vector+graph" || mode === "vector+bm25+graph";
-    const classification = classifyQuery(query);
-    const adaptiveWeights = classification.weights;
-    let filterRepos = opts?.repoFilter ?? opts?.repos;
-    if (!filterRepos && this.queryRouter) {
-      try {
-        const routeResult = await this.queryRouter.route(query);
-        if (routeResult.strategy === "filtered") {
-          filterRepos = routeResult.repos;
-        }
-      } catch {
-      }
-    }
-    const filter = filterRepos ? `repoName IN (${filterRepos.map((r) => `'${r}'`).join(",")})` : void 0;
-    let queryEmbedding = null;
-    if (useVector) {
-      queryEmbedding = getCachedEmbedding(query);
-      if (!queryEmbedding) {
-        queryEmbedding = await this.embedder.embedSingle(query);
-        cacheEmbedding(query, queryEmbedding);
-      }
-    }
-    const [vectorResults, bm25Results] = await Promise.all([
-      useVector && queryEmbedding ? this.vectorStore.vectorSearch(queryEmbedding, { limit: 50, filter }) : Promise.resolve([]),
-      useBm25 ? this.vectorStore.fullTextSearch(query, 50) : Promise.resolve([])
-    ]);
-    if (mode === "vector") {
-      const selected2 = packWithinBudget(vectorResults, maxTokens, maxChunks);
-      return { chunks: selected2, graphContext: "", totalTokens: sumTokens(selected2), query };
-    }
-    if (mode === "bm25") {
-      const selected2 = packWithinBudget(bm25Results, maxTokens, maxChunks);
-      return { chunks: selected2, graphContext: "", totalTokens: sumTokens(selected2), query };
-    }
-    const wV = adaptiveWeights.vector ?? this.config.hybridWeights.vector;
-    const wB = adaptiveWeights.bm25 ?? this.config.hybridWeights.bm25;
-    const retrievalSets = [];
-    const weights = [];
-    if (vectorResults.length > 0) {
-      retrievalSets.push(vectorResults);
-      weights.push(wV);
-    }
-    if (bm25Results.length > 0) {
-      retrievalSets.push(bm25Results);
-      weights.push(wB);
-    }
-    const fused = retrievalSets.length > 1 ? reciprocalRankFusion(retrievalSets, weights) : retrievalSets[0] ?? [];
-    let astChunks = [];
-    if (useGraph && this.graph) {
-      const seedNodeIds = this.resolveFusedSeeds(fused, 5);
-      if (seedNodeIds.length > 0) {
-        const expandedNodeIds = this.tripartiteExpand(seedNodeIds);
-        if (expandedNodeIds.length > 0) {
-          const lookups = expandedNodeIds.map((nodeId) => {
-            const parts = nodeId.split("::");
-            if (parts.length >= 3) {
-              return { repoName: parts[0], filePath: parts[1], entityName: parts.slice(2).join("::") };
-            }
-            return { repoName: parts[0], filePath: parts.slice(1).join("::") };
-          });
-          astChunks = await this.vectorStore.getChunksByEntity(lookups);
-        }
-      }
-    }
-    const candidatePool = deduplicateChunks([...fused.slice(0, 15), ...astChunks]);
-    let finalChunks;
-    if (this.reranker && candidatePool.length > 1) {
-      try {
-        const documents = candidatePool.map((sc) => sc.chunk.contextualizedContent || sc.chunk.content);
-        const ranked = await this.reranker.rerank(query, documents, maxChunks);
-        finalChunks = ranked.map((r) => ({
-          ...candidatePool[r.index],
-          score: r.score,
-          source: "fused"
-        }));
-      } catch {
-        finalChunks = candidatePool;
-      }
-    } else {
-      finalChunks = candidatePool;
-    }
-    const selected = packWithinBudget(finalChunks, maxTokens, maxChunks);
-    const graphContext = useGraph && this.graph ? this.graph.exportForPrompt(2e3) ?? "" : "";
-    return {
-      chunks: selected,
-      graphContext,
-      totalTokens: sumTokens(selected),
-      query
-    };
-  }
-  // ---------------------------------------------------------------
-  // Seed resolution: map chunk entities to graph node IDs
-  // ---------------------------------------------------------------
-  resolveFusedSeeds(fused, maxSeeds) {
-    if (!this.graph) return [];
-    const g = this.graph.getGraph();
-    const seenFiles = /* @__PURE__ */ new Set();
-    const nodeIds = [];
-    for (const sc of fused) {
-      if (nodeIds.length >= maxSeeds) break;
-      const { repoName, entityName, filePath } = sc.chunk;
-      if (!entityName) continue;
-      if (seenFiles.has(filePath)) continue;
-      seenFiles.add(filePath);
-      const baseName = entityName.replace(/\$\d+$/, "");
-      const exactId = `${repoName}::${filePath}::${baseName}`;
-      if (g.hasNode(exactId)) {
-        nodeIds.push(exactId);
-        continue;
-      }
-      const exactIdOrig = `${repoName}::${filePath}::${entityName}`;
-      if (g.hasNode(exactIdOrig)) {
-        nodeIds.push(exactIdOrig);
-        continue;
-      }
-      let found = false;
-      g.forEachNode((nodeId, attrs) => {
-        if (!found && attrs.repo === repoName && attrs.label === baseName) {
-          nodeIds.push(nodeId);
-          found = true;
-        }
-      });
-    }
-    return nodeIds;
-  }
-  // ---------------------------------------------------------------
-  // Tripartite expansion: dependencies + dependents + definitions
-  // ---------------------------------------------------------------
-  tripartiteExpand(seedNodeIds) {
-    if (!this.graph) return [];
-    const g = this.graph.getGraph();
-    const expanded = /* @__PURE__ */ new Set();
-    const seedSet = new Set(seedNodeIds);
-    for (const seed of seedNodeIds) {
-      if (!g.hasNode(seed)) continue;
-      g.forEachOutEdge(seed, (_edge, attrs, _src, tgt) => {
-        const conf = attrs.confidence ?? 0.8;
-        if (conf >= 0.7 && attrs.type !== "contains" && !seedSet.has(tgt)) {
-          expanded.add(tgt);
-        }
-      });
-      g.forEachInEdge(seed, (_edge, attrs, src) => {
-        const conf = attrs.confidence ?? 0.8;
-        if (conf >= 0.7 && attrs.type !== "contains" && !seedSet.has(src)) {
-          expanded.add(src);
-        }
-      });
-    }
-    return [...expanded].filter((nodeId) => {
-      const type = g.getNodeAttributes(nodeId)?.type;
-      return type !== "module" && type !== "package";
-    });
-  }
-}
-function reciprocalRankFusion(resultSets, weights, k = 60) {
-  const scoreMap = /* @__PURE__ */ new Map();
-  for (let setIdx = 0; setIdx < resultSets.length; setIdx++) {
-    const results = resultSets[setIdx];
-    const weight = weights[setIdx] ?? 1;
-    for (let rank = 0; rank < results.length; rank++) {
-      const { chunk } = results[rank];
-      const rrfScore = weight * (1 / (k + rank + 1));
-      const existing = scoreMap.get(chunk.id);
-      if (existing) {
-        existing.score += rrfScore;
-      } else {
-        scoreMap.set(chunk.id, { chunk, score: rrfScore });
-      }
-    }
-  }
-  return Array.from(scoreMap.values()).sort((a, b) => b.score - a.score).map(({ chunk, score }) => ({
-    chunk,
-    score,
-    source: "fused"
-  }));
-}
-function deduplicateChunks(chunks) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const sc of chunks) {
-    if (seen.has(sc.chunk.id)) continue;
-    seen.add(sc.chunk.id);
-    result.push(sc);
-  }
-  return result;
-}
-function packWithinBudget(chunks, maxTokens, maxChunks) {
-  const selected = [];
-  let totalTokens = 0;
-  for (const sc of chunks) {
-    if (maxChunks && selected.length >= maxChunks) break;
-    if (totalTokens + sc.chunk.tokens > maxTokens) break;
-    selected.push(sc);
-    totalTokens += sc.chunk.tokens;
-  }
-  return selected;
-}
-function sumTokens(chunks) {
-  return chunks.reduce((sum, sc) => sum + sc.chunk.tokens, 0);
-}
-export {
-  HybridRetriever
-};

package/dist/core/semantic-edge-detector.js

@@ -1,147 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-const DI_EVENT_PATTERNS = [
-  // DI patterns
-  /\@Injectable|\@Inject|\@Autowired/,
-  /container\.(?:register|bind|singleton|resolve)/,
-  /\$this->app->(?:bind|singleton|make)/,
-  /providers:\s*\[/,
-  // Event patterns
-  /\.on\s*\(|\.emit\s*\(|\.addEventListener/,
-  /EventEmitter|@Subscribe|@Listener|@EventHandler/,
-  /event\s*\(\s*['"`]/,
-  // Routing patterns
-  /\@Controller|\@Get|\@Post|\@Put|\@Delete|\@RequestMapping/,
-  /app\.(?:get|post|put|delete|use)\s*\(/,
-  /router\.(?:get|post|put|delete)\s*\(/,
-  // Factory/Registry patterns
-  /\.register\s*\(|\.factory\s*\(/,
-  /switch\s*\([^)]*type[^)]*\)/i
-];
-function fileMatchesDIPatterns(content) {
-  return DI_EVENT_PATTERNS.some((p) => p.test(content));
-}
-function findOrphanEntityFiles(graph) {
-  const outgoing = /* @__PURE__ */ new Map();
-  for (const edge of graph.links) {
-    if (edge.type === "contains") continue;
-    outgoing.set(edge.source, (outgoing.get(edge.source) ?? 0) + 1);
-  }
-  const orphanFiles = /* @__PURE__ */ new Set();
-  for (const node of graph.nodes) {
-    if (node.type === "module" || node.type === "package") continue;
-    if ((outgoing.get(node.id) ?? 0) === 0 && node.file) {
-      orphanFiles.add(node.file);
-    }
-  }
-  return orphanFiles;
-}
-const SEMANTIC_EDGE_PROMPT = `You are analyzing source code to find structural relationships that static AST analysis missed.
-
-Given code files and the list of known entities, identify relationships of these types ONLY:
-1. **di-inject**: A class receives another class via constructor injection, decorator, or container registration
-2. **event-wire**: An entity emits/publishes an event that another entity subscribes to/handles
-3. **config-route**: A config file or decorator maps a path/key to a handler function
-4. **dynamic-dispatch**: A factory/registry pattern where a string key maps to a class/function
-
-Respond with ONLY valid JSON (no markdown, no explanation):
-{
-  "edges": [
-    {
-      "source": "file/path.ext::EntityName",
-      "target": "file/path.ext::EntityName",
-      "type": "di-inject",
-      "evidence": "brief explanation",
-      "confidence": 0.8
-    }
-  ]
-}
-
-Rules:
-- ONLY report edges between entities in the Known Entities list below
-- ONLY report edges with confidence >= 0.7
-- Do NOT report edges detectable by import analysis or direct function calls
-- If no relationships found, return {"edges": []}
-
-## Known Entities
-{ENTITY_LIST}
-
-## Code Files
-{FILE_CONTENTS}`;
-async function detectSemanticEdges(repoPath, graph, callLLM, opts) {
-  const maxFiles = opts?.maxFiles ?? 30;
-  const allEdges = [];
-  let totalTokens = 0;
-  const orphanFiles = findOrphanEntityFiles(graph);
-  const patternFiles = /* @__PURE__ */ new Set();
-  for (const node of graph.nodes) {
-    if (node.type !== "module" || !node.file) continue;
-    try {
-      const content = readFileSync(join(repoPath, node.file), "utf-8");
-      if (fileMatchesDIPatterns(content)) {
-        patternFiles.add(node.file);
-      }
-    } catch {
-    }
-  }
-  const candidateFiles = [.../* @__PURE__ */ new Set([...orphanFiles, ...patternFiles])].slice(0, maxFiles);
-  if (candidateFiles.length === 0) return { edges: [], filesAnalyzed: 0, tokensUsed: 0 };
-  const nodeSet = new Set(graph.nodes.map((n) => n.id));
-  const entityList = graph.nodes.filter((n) => n.type !== "module" && n.type !== "package").map((n) => `${n.id} (${n.type})`).join("\n");
-  const batches = [];
-  let currentBatch = [];
-  let currentSize = 0;
-  for (const relPath of candidateFiles) {
-    try {
-      const content = readFileSync(join(repoPath, relPath), "utf-8");
-      const trimmed = content.slice(0, 3e3);
-      if (currentSize + trimmed.length > 12e3) {
-        if (currentBatch.length > 0) batches.push(currentBatch);
-        currentBatch = [];
-        currentSize = 0;
-      }
-      currentBatch.push({ relPath, content: trimmed });
-      currentSize += trimmed.length;
-    } catch {
-    }
-  }
-  if (currentBatch.length > 0) batches.push(currentBatch);
-  for (const batch of batches) {
-    const fileContents = batch.map((f) => `### ${f.relPath}
-\`\`\`
-${f.content}
-\`\`\``).join("\n\n");
-    const prompt = SEMANTIC_EDGE_PROMPT.replace("{ENTITY_LIST}", entityList.slice(0, 5e3)).replace("{FILE_CONTENTS}", fileContents);
-    try {
-      const result = await callLLM(prompt);
-      totalTokens += result.inputTokens + result.outputTokens;
-      let jsonStr = result.content.trim();
-      const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
-      if (jsonMatch) jsonStr = jsonMatch[1].trim();
-      const parsed = JSON.parse(jsonStr);
-      if (!Array.isArray(parsed?.edges)) continue;
-      for (const edge of parsed.edges) {
-        if (nodeSet.has(edge.source) && nodeSet.has(edge.target) && edge.source !== edge.target) {
-          const confidence = typeof edge.confidence === "number" ? Math.min(edge.confidence, 0.95) : 0.75;
-          if (confidence >= 0.7) {
-            allEdges.push({
-              source: edge.source,
-              target: edge.target,
-              type: edge.type || "semantic",
-              confidence
-            });
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  return {
-    edges: allEdges,
-    filesAnalyzed: candidateFiles.length,
-    tokensUsed: totalTokens
-  };
-}
-export {
-  detectSemanticEdges
-};