@esankhan3/code-search-mcp 0.0.1

package/dist/tools/graph.js

@@ -0,0 +1,193 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getKnowledgeBasePath } from "../core/config.js";
+function registerGraphTools() {
+  return [
+    {
+      name: "get_repo_graph",
+      description: "Get the AST knowledge graph for a repo \u2014 entities (functions, classes, types) and their relationships (calls, imports, inheritance).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo: { type: "string", description: "Repository name" }
+        },
+        required: ["repo"]
+      }
+    },
+    {
+      name: "get_cross_repo_edges",
+      description: "Get connections between repos \u2014 shared deps, Kafka topics, HTTP routes, database tables, gRPC services, etc.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo: { type: "string", description: "Filter to edges involving this repo (optional)" }
+        }
+      }
+    },
+    {
+      name: "find_callers",
+      description: "Find all functions/methods that call a given function. Uses the AST graph.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          function: { type: "string", description: "Function name to find callers of" },
+          repo: { type: "string", description: "Limit search to this repo (optional)" }
+        },
+        required: ["function"]
+      }
+    },
+    {
+      name: "find_dependencies",
+      description: "Find what a function depends on \u2014 calls, imports, type references.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          function: { type: "string", description: "Function name" },
+          repo: { type: "string", description: "Limit to this repo (optional)" }
+        },
+        required: ["function"]
+      }
+    },
+    {
+      name: "impact_analysis",
+      description: "Analyze what would be affected if a file or entity is changed. Traces callers, dependents, and cross-repo connections.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          file: { type: "string", description: "File path (relative to repo root)" },
+          entity: { type: "string", description: "Specific entity name (optional \u2014 if omitted, analyzes all entities in the file)" },
+          repo: { type: "string", description: "Repository name" }
+        },
+        required: ["file", "repo"]
+      }
+    }
+  ];
+}
+async function handleGraphTool(name, args, ctx) {
+  if (!["get_repo_graph", "get_cross_repo_edges", "find_callers", "find_dependencies", "impact_analysis"].includes(name)) return null;
+  try {
+    const kbPath = getKnowledgeBasePath(ctx.projectName);
+    if (name === "get_repo_graph") {
+      const repo = args.repo;
+      const graphPath = join(kbPath, repo, "graph.json");
+      if (!existsSync(graphPath)) {
+        return { content: [{ type: "text", text: `No graph found for repo "${repo}"` }] };
+      }
+      const graph = JSON.parse(readFileSync(graphPath, "utf-8"));
+      const summary = `# ${repo} AST Graph
+
+- **Nodes:** ${graph.nodes?.length ?? 0}
+- **Edges:** ${graph.links?.length ?? 0}
+
+## Entities
+${(graph.nodes ?? []).slice(0, 50).map((n) => `- \`${n.id}\` (${n.type})`).join("\n")}
+
+${graph.nodes?.length > 50 ? `... and ${graph.nodes.length - 50} more` : ""}`;
+      return { content: [{ type: "text", text: summary }] };
+    }
+    if (name === "get_cross_repo_edges") {
+      const sysGraphPath = join(kbPath, "system_graph_v2.json");
+      if (!existsSync(sysGraphPath)) {
+        return { content: [{ type: "text", text: "No system graph found. Build KB first." }] };
+      }
+      const sysGraph = JSON.parse(readFileSync(sysGraphPath, "utf-8"));
+      const edges = sysGraph.edges ?? [];
+      const repo = args.repo;
+      const relevant = repo ? edges.filter((e) => (e.source ?? "").startsWith(repo + "::") || (e.target ?? "").startsWith(repo + "::")) : edges;
+      const crossRepo = relevant.filter((e) => {
+        const src = (e.source ?? "").split("::")[0];
+        const tgt = (e.target ?? "").split("::")[0];
+        return src && tgt && src !== tgt;
+      });
+      if (crossRepo.length === 0) {
+        return { content: [{ type: "text", text: repo ? `No cross-repo edges found for "${repo}"` : "No cross-repo edges found" }] };
+      }
+      const text = crossRepo.slice(0, 50).map((e) => {
+        const attrs = e.attributes ?? {};
+        return `- ${(e.source ?? "").split("::")[0]} \u2192 ${(e.target ?? "").split("::")[0]} (${attrs.relation ?? attrs.type ?? "edge"})`;
+      }).join("\n");
+      return { content: [{ type: "text", text: `# Cross-Repo Edges${repo ? ` for ${repo}` : ""}
+
+${crossRepo.length} edges found:
+
+${text}${crossRepo.length > 50 ? `
+
+... and ${crossRepo.length - 50} more` : ""}` }] };
+    }
+    if (name === "find_callers" || name === "find_dependencies") {
+      const funcName = args.function;
+      const repoFilter = args.repo;
+      const sysGraphPath = join(kbPath, "system_graph_v2.json");
+      if (!existsSync(sysGraphPath)) {
+        return { content: [{ type: "text", text: "No system graph found." }] };
+      }
+      const sysGraph = JSON.parse(readFileSync(sysGraphPath, "utf-8"));
+      const edges = sysGraph.edges ?? [];
+      const matchingNodes = (sysGraph.nodes ?? []).filter((n) => {
+        const label = n.attributes?.label ?? n.key ?? "";
+        const matchesName = label.includes(funcName) || (n.key ?? "").includes(funcName);
+        const matchesRepo = !repoFilter || (n.key ?? "").startsWith(repoFilter + "::");
+        return matchesName && matchesRepo;
+      });
+      if (matchingNodes.length === 0) {
+        return { content: [{ type: "text", text: `No entity found matching "${funcName}"${repoFilter ? ` in ${repoFilter}` : ""}` }] };
+      }
+      const nodeKeys = new Set(matchingNodes.map((n) => n.key));
+      let results;
+      if (name === "find_callers") {
+        results = edges.filter((e) => nodeKeys.has(e.target)).map((e) => e.source);
+      } else {
+        results = edges.filter((e) => nodeKeys.has(e.source)).map((e) => e.target);
+      }
+      const unique = [...new Set(results)].slice(0, 30);
+      const direction = name === "find_callers" ? "Callers of" : "Dependencies of";
+      return { content: [{ type: "text", text: `# ${direction} "${funcName}"
+
+${unique.length} found:
+${unique.map((r) => `- \`${r}\``).join("\n")}` }] };
+    }
+    if (name === "impact_analysis") {
+      const file = args.file;
+      const repo = args.repo;
+      const entity = args.entity;
+      const sysGraphPath = join(kbPath, "system_graph_v2.json");
+      if (!existsSync(sysGraphPath)) {
+        return { content: [{ type: "text", text: "No system graph found." }] };
+      }
+      const sysGraph = JSON.parse(readFileSync(sysGraphPath, "utf-8"));
+      const edges = sysGraph.edges ?? [];
+      const nodes = sysGraph.nodes ?? [];
+      const fileNodes = nodes.filter((n) => {
+        const key = n.key ?? "";
+        const matchesFile = key.includes(`${repo}::${file}::`);
+        const matchesEntity = !entity || key.includes(entity);
+        return matchesFile && matchesEntity;
+      });
+      const nodeKeys = new Set(fileNodes.map((n) => n.key));
+      const dependents = edges.filter((e) => nodeKeys.has(e.target) && !nodeKeys.has(e.source));
+      const dependentRepos = new Set(dependents.map((e) => (e.source ?? "").split("::")[0]));
+      const text = [
+        `# Impact Analysis: ${repo}/${file}${entity ? `::${entity}` : ""}`,
+        "",
+        `## Entities in scope: ${fileNodes.length}`,
+        ...fileNodes.slice(0, 20).map((n) => `- \`${n.key}\``),
+        "",
+        `## Dependents: ${dependents.length} edges from ${dependentRepos.size} repos`,
+        ...dependents.slice(0, 30).map((e) => `- \`${e.source}\` \u2192 \`${e.target}\` (${(e.attributes ?? {}).relation ?? "edge"})`),
+        dependents.length > 30 ? `
+... and ${dependents.length - 30} more` : "",
+        "",
+        `## Affected repos: ${[...dependentRepos].join(", ") || "none"}`
+      ].join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+    return null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: `Graph tool error: ${msg}` }] };
+  }
+}
+export {
+  handleGraphTool,
+  registerGraphTools
+};

package/dist/tools/index-tools.js

@@ -0,0 +1,43 @@
+import { KnowledgeIndexer } from "../core/indexer.js";
+const TOOL_NAMES = ["index_status"];
+function registerIndexTools() {
+  return [
+    {
+      name: "index_status",
+      description: "Get current index stats \u2014 chunk count, embedding provider, repos indexed, last indexed time.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    }
+  ];
+}
+async function handleIndexTool(name, args, ctx) {
+  if (!TOOL_NAMES.includes(name)) return null;
+  try {
+    if (name === "index_status") {
+      const indexer = new KnowledgeIndexer();
+      const stats = await indexer.getStats(ctx.projectName);
+      const lines = [
+        `# Index Status: ${ctx.projectName}`,
+        "",
+        `- **Chunks:** ${stats.totalChunks.toLocaleString()}`,
+        `- **Embedding provider:** ${stats.embeddingProvider}`,
+        `- **Last indexed:** ${stats.lastIndexed || "never"}`,
+        `- **Repos:** ${stats.repos.length}`,
+        "",
+        "## Repos",
+        ...stats.repos.map((r) => `- ${r.name}: ${r.chunkCount} chunks`)
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    return null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: `Index tool error: ${msg}` }] };
+  }
+}
+export {
+  handleIndexTool,
+  registerIndexTools
+};

package/dist/tools/profile.js

@@ -0,0 +1,88 @@
+import { loadAllProfiles, loadProfile } from "../core/repo-profiler.js";
+import { discoverRepos } from "../core/indexer.js";
+function registerProfileTools() {
+  return [
+    {
+      name: "list_repos",
+      description: "List all indexed repos with their role, domain, and description.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "get_repo_profile",
+      description: "Get the LLM-generated profile for a repo \u2014 role, domain, tech stack, exposed/consumed endpoints.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo: { type: "string", description: "Repository name" }
+        },
+        required: ["repo"]
+      }
+    }
+  ];
+}
+async function handleProfileTool(name, args, ctx) {
+  if (!["list_repos", "get_repo_profile"].includes(name)) return null;
+  try {
+    if (name === "list_repos") {
+      const profiles = loadAllProfiles(ctx.projectName);
+      if (profiles.length === 0) {
+        if (ctx.directoryPath) {
+          const repos = discoverRepos(ctx.directoryPath);
+          const text2 = repos.map((r) => `- **${r.name}** (${r.language})`).join("\n");
+          return { content: [{ type: "text", text: `# Repos (${repos.length}, not yet profiled)
+
+${text2}` }] };
+        }
+        return { content: [{ type: "text", text: "No repos found. Run reindex first." }] };
+      }
+      const text = profiles.map(
+        (p) => `- **${p.name}** \u2014 ${p.role} | ${p.domain} | ${p.description}`
+      ).join("\n");
+      return { content: [{ type: "text", text: `# Indexed Repos (${profiles.length})
+
+${text}` }] };
+    }
+    if (name === "get_repo_profile") {
+      const repo = args.repo;
+      const profile = loadProfile(ctx.projectName, repo);
+      if (!profile) {
+        return { content: [{ type: "text", text: `No profile found for "${repo}". Run reindex to generate profiles.` }] };
+      }
+      const lines = [
+        `# ${profile.name}`,
+        "",
+        `**Role:** ${profile.role}`,
+        `**Domain:** ${profile.domain}`,
+        `**Description:** ${profile.description}`,
+        `**Technologies:** ${profile.technologies.join(", ")}`,
+        `**Entry points:** ${profile.entryPoints.join(", ")}`,
+        ""
+      ];
+      if (profile.exposes.length > 0) {
+        lines.push("## Exposes");
+        for (const e of profile.exposes) {
+          lines.push(`- **${e.type}:** \`${e.identifier}\` \u2014 ${e.description}`);
+        }
+        lines.push("");
+      }
+      if (profile.consumes.length > 0) {
+        lines.push("## Consumes");
+        for (const c of profile.consumes) {
+          lines.push(`- **${c.type}:** \`${c.identifier}\` \u2014 ${c.description}`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    return null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: `Profile tool error: ${msg}` }] };
+  }
+}
+export {
+  handleProfileTool,
+  registerProfileTools
+};

package/dist/tools/search.js

@@ -0,0 +1,84 @@
+import { getRetriever } from "../core/indexer.js";
+function registerSearchTools() {
+  return [
+    {
+      name: "search_code",
+      description: "Hybrid search across all repos using vector + BM25 + graph expansion + reranking. Best for general queries.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query (natural language or code identifier)" },
+          maxResults: { type: "number", description: "Max results to return (default: 10)" },
+          repos: { type: "array", items: { type: "string" }, description: "Filter to specific repos (optional)" }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "search_semantic",
+      description: 'Vector-only semantic search. Best for conceptual questions like "how does X work?"',
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          maxResults: { type: "number", description: "Max results (default: 10)" }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "search_exact",
+      description: "BM25 keyword search. Best for exact function names, error codes, file paths.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Exact search query" },
+          maxResults: { type: "number", description: "Max results (default: 10)" }
+        },
+        required: ["query"]
+      }
+    }
+  ];
+}
+async function handleSearchTool(name, args, ctx) {
+  if (!["search_code", "search_semantic", "search_exact"].includes(name)) return null;
+  if (!ctx.indexReady) {
+    return { content: [{ type: "text", text: "Index not ready. Run reindex tool or wait for auto-indexing to complete." }] };
+  }
+  try {
+    const retriever = await getRetriever(ctx.projectName);
+    const query = args.query;
+    const maxResults = args.maxResults || 10;
+    const repos = args.repos;
+    const modeMap = {
+      search_code: "vector+bm25+graph",
+      search_semantic: "vector",
+      search_exact: "bm25"
+    };
+    const result = await retriever.retrieve(query, {
+      maxChunks: maxResults,
+      repoFilter: repos,
+      mode: modeMap[name]
+    });
+    if (result.chunks.length === 0) {
+      return { content: [{ type: "text", text: `No results found for "${query}"` }] };
+    }
+    const text = result.chunks.map((sc, i) => {
+      const c = sc.chunk;
+      return `### ${i + 1}. ${c.repoName}/${c.filePath}:${c.startLine} (score: ${sc.score.toFixed(3)}, source: ${sc.source})
+\`\`\`${c.language}
+${c.content}
+\`\`\``;
+    }).join("\n\n");
+    return { content: [{ type: "text", text: `Found ${result.chunks.length} results for "${query}" (${result.totalTokens} tokens):
+
+${text}` }] };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: `Search failed: ${msg}` }] };
+  }
+}
+export {
+  handleSearchTool,
+  registerSearchTools
+};

package/dist/transports/http-transport.js

@@ -0,0 +1,162 @@
+import { createServer } from "node:http";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createAuthMiddleware } from "../middleware/auth.js";
+async function startHttpTransport(opts) {
+  const { config, createMcpServer, onReady, getHealth } = opts;
+  const authenticate = createAuthMiddleware(config);
+  const sessions = /* @__PURE__ */ new Map();
+  const SESSION_TTL_MS = 30 * 60 * 1e3;
+  const MAX_SESSIONS = 100;
+  setInterval(() => {
+    const now = Date.now();
+    for (const [id, session] of sessions) {
+      if (now - session.lastActivity > SESSION_TTL_MS) {
+        sessions.delete(id);
+      }
+    }
+  }, 5 * 60 * 1e3).unref();
+  const httpServer = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const path = url.pathname;
+    const requestId = randomUUID().slice(0, 8);
+    res.setHeader("X-Request-ID", requestId);
+    if (path === "/health" && req.method === "GET") {
+      const health = getHealth?.() ?? {};
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        status: "ok",
+        activeSessions: sessions.size,
+        ...health
+      }));
+      return;
+    }
+    if (path === "/status" && req.method === "GET") {
+      const status = opts.getStatus?.() ?? {};
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(status, null, 2));
+      return;
+    }
+    if (path === "/index" && req.method === "POST") {
+      if (config.authEnabled) {
+        const identity = authenticate(req, res);
+        if (!identity) return;
+      }
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      req.on("end", async () => {
+        try {
+          const parsed = JSON.parse(body);
+          if (!parsed.path) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "`path` is required" }));
+            return;
+          }
+          if (!opts.onIndex) {
+            res.writeHead(501, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Indexing handler not configured" }));
+            return;
+          }
+          const result = await opts.onIndex(parsed);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(result));
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: msg }));
+          }
+        }
+      });
+      return;
+    }
+    if (path === "/mcp") {
+      if (config.authEnabled) {
+        const identity = authenticate(req, res);
+        if (!identity) return;
+      }
+      if (req.method === "POST") {
+        const sessionId = req.headers["mcp-session-id"];
+        if (sessionId && sessions.has(sessionId)) {
+          sessions.get(sessionId).lastActivity = Date.now();
+          await sessions.get(sessionId).transport.handleRequest(req, res);
+          return;
+        }
+        if (sessionId && !sessions.has(sessionId)) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid session ID. Session may have expired." }));
+          return;
+        }
+        if (sessions.size >= MAX_SESSIONS) {
+          res.writeHead(503, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Too many active sessions. Try again later." }));
+          return;
+        }
+        try {
+          const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID()
+          });
+          const { server: mcpServer } = await createMcpServer();
+          await mcpServer.connect(transport);
+          transport.onclose = () => {
+            for (const [id, s] of sessions) {
+              if (s.transport === transport) {
+                sessions.delete(id);
+                break;
+              }
+            }
+          };
+          await transport.handleRequest(req, res);
+          const newSessionId = res.getHeader("mcp-session-id");
+          if (newSessionId) {
+            sessions.set(newSessionId, { transport, lastActivity: Date.now() });
+          }
+        } catch (err) {
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to create session" }));
+          }
+        }
+        return;
+      }
+      if (req.method === "GET") {
+        const sessionId = req.headers["mcp-session-id"];
+        if (sessionId && sessions.has(sessionId)) {
+          await sessions.get(sessionId).transport.handleRequest(req, res);
+          return;
+        }
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Session ID required for GET requests" }));
+        return;
+      }
+      if (req.method === "DELETE") {
+        const sessionId = req.headers["mcp-session-id"];
+        if (sessionId && sessions.has(sessionId)) {
+          await sessions.get(sessionId).transport.handleRequest(req, res);
+          sessions.delete(sessionId);
+          return;
+        }
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid session ID" }));
+        return;
+      }
+      res.writeHead(405, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Method not allowed" }));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+  return new Promise((resolve) => {
+    httpServer.listen(config.port, config.host, () => {
+      const url = `http://${config.host === "0.0.0.0" ? "localhost" : config.host}:${config.port}`;
+      onReady?.(url);
+      resolve();
+    });
+  });
+}
+export {
+  startHttpTransport
+};