@esankhan3/code-search-mcp 0.0.2 → 0.2.0

package/dist/core/service-mesh-inferrer.js

@@ -1,241 +0,0 @@
-import { runClaude } from "./claude-runner.js";
-const SEPARATOR = "/";
-function normalizeIdentifier(id) {
-  let normalized = id.toLowerCase();
-  normalized = normalized.replace(/[.\-_]+/g, SEPARATOR);
-  normalized = normalized.replace(/^\/+|\/+$/g, "");
-  normalized = normalized.replace(/^(?:api\/)?v\d+\//i, "");
-  normalized = normalized.replace(/:[a-zA-Z_]+/g, ":param");
-  normalized = normalized.replace(/\{[a-zA-Z_]+\}/g, ":param");
-  normalized = normalized.replace(/<[a-zA-Z_]+>/g, ":param");
-  return normalized;
-}
-function identifierSimilarity(a, b) {
-  const na = normalizeIdentifier(a);
-  const nb = normalizeIdentifier(b);
-  if (na === nb) return 1;
-  if (na.includes(nb) || nb.includes(na)) return 0.8;
-  const segsA = new Set(na.split(SEPARATOR).filter(Boolean));
-  const segsB = new Set(nb.split(SEPARATOR).filter(Boolean));
-  if (segsA.size === 0 || segsB.size === 0) return 0;
-  let intersection = 0;
-  for (const seg of segsA) {
-    if (segsB.has(seg)) intersection++;
-  }
-  const union = (/* @__PURE__ */ new Set([...segsA, ...segsB])).size;
-  return Math.min(0.7, intersection / union);
-}
-const MATCH_RULES = [
-  // Kafka: producer -> consumer on same topic
-  { producerType: "kafka-producer", consumerType: "kafka-consumer", edgeType: "kafka", baseConfidence: 0.95, threshold: 0.8 },
-  // HTTP: exposed path -> consumed path
-  { producerType: "http", consumerType: "http", edgeType: "http", baseConfidence: 0.85, threshold: 0.6 },
-  // gRPC: exposed service -> consumed service
-  { producerType: "grpc", consumerType: "grpc", edgeType: "grpc", baseConfidence: 0.95, threshold: 0.8 },
-  // Database: shared table references
-  { producerType: "database", consumerType: "database", edgeType: "database", baseConfidence: 0.8, threshold: 0.8 },
-  // Redis: shared key patterns
-  { producerType: "redis", consumerType: "redis", edgeType: "redis", baseConfidence: 0.75, threshold: 0.7 },
-  // S3: shared bucket identifiers
-  { producerType: "s3", consumerType: "s3", edgeType: "s3", baseConfidence: 0.8, threshold: 0.8 }
-];
-function matchEndpoints(profiles) {
-  const edges = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const rule of MATCH_RULES) {
-    const isBidirectional = ["database", "redis", "s3"].includes(rule.producerType);
-    for (let i = 0; i < profiles.length; i++) {
-      for (let j = 0; j < profiles.length; j++) {
-        if (i === j) continue;
-        const repoA = profiles[i];
-        const repoB = profiles[j];
-        if (isBidirectional && i > j) continue;
-        const exposedA = repoA.exposes.filter((e) => e.type === rule.producerType);
-        const consumedB = isBidirectional ? [...repoB.consumes.filter((e) => e.type === rule.consumerType), ...repoB.exposes.filter((e) => e.type === rule.producerType)] : repoB.consumes.filter((e) => e.type === rule.consumerType);
-        for (const exposed of exposedA) {
-          for (const consumed of consumedB) {
-            const similarity = identifierSimilarity(exposed.identifier, consumed.identifier);
-            if (similarity < rule.threshold) continue;
-            const confidence = rule.baseConfidence * similarity;
-            const edgeKey = `${repoA.name}:${repoB.name}:${rule.edgeType}:${normalizeIdentifier(exposed.identifier)}`;
-            if (seen.has(edgeKey)) continue;
-            seen.add(edgeKey);
-            edges.push({
-              sourceRepo: repoA.name,
-              sourceNode: exposed.identifier,
-              targetRepo: repoB.name,
-              targetNode: consumed.identifier,
-              edgeType: rule.edgeType,
-              evidence: `${repoA.name} exposes ${exposed.type}:${exposed.identifier} matched with ${repoB.name} ${isBidirectional ? "exposes" : "consumes"} ${consumed.type}:${consumed.identifier} (similarity: ${similarity.toFixed(2)})`,
-              confidence: Math.round(confidence * 100) / 100
-            });
-          }
-        }
-      }
-    }
-  }
-  return edges;
-}
-const SYSTEM_PROMPT = `You are a software architect analyzing an organization's service architecture.
-You will be given profiles of repositories that have NO detected connections to other repos.
-Based on their roles, technologies, domains, and descriptions, identify likely connections.
-
-Consider:
-- Shared databases (same DB tech + similar domain = likely shared DB)
-- Config-driven routing (gateway -> backend services)
-- Cron/scheduler -> worker relationships
-- Shared infrastructure services (logging, auth, notifications)
-- Domain proximity (repos in same domain likely interact)
-
-Respond with ONLY valid JSON array:
-[
-  {
-    "source": "repo-name-a",
-    "target": "repo-name-b",
-    "type": "http|kafka|grpc|database|redis|s3|other",
-    "evidence": "Both repos are in email-delivery domain, A is gateway, B is worker",
-    "confidence": 0.7
-  }
-]
-
-Rules:
-- Only suggest connections with confidence >= 0.6
-- Be conservative \u2014 better to miss a connection than hallucinate one
-- Use the repo descriptions to understand actual purpose, not just names`;
-function parseJsonArray(raw) {
-  let cleaned = raw.trim();
-  cleaned = cleaned.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?\s*```$/i, "");
-  cleaned = cleaned.trim();
-  try {
-    const parsed = JSON.parse(cleaned);
-    if (Array.isArray(parsed)) return parsed;
-    return [];
-  } catch {
-    const arrayMatch = cleaned.match(/\[[\s\S]*\]/);
-    if (arrayMatch) {
-      try {
-        return JSON.parse(arrayMatch[0]);
-      } catch {
-        return [];
-      }
-    }
-    return [];
-  }
-}
-function toEdgeType(raw) {
-  const valid = [
-    "http",
-    "kafka",
-    "grpc",
-    "database",
-    "redis",
-    "s3"
-  ];
-  const lower = raw.toLowerCase();
-  const match = valid.find((v) => v === lower);
-  return match ?? "llm-inferred";
-}
-async function inferOrphanConnections(profiles, existingEdges, opts) {
-  const connectedRepos = /* @__PURE__ */ new Set();
-  for (const edge of existingEdges) {
-    connectedRepos.add(edge.sourceRepo);
-    connectedRepos.add(edge.targetRepo);
-  }
-  const orphans = profiles.filter((p) => !connectedRepos.has(p.name));
-  if (orphans.length === 0) return [];
-  const orphanDomains = new Set(orphans.map((p) => p.domain));
-  const contextProfiles = profiles.filter(
-    (p) => orphanDomains.has(p.domain) || !connectedRepos.has(p.name)
-  );
-  const slimProfiles = contextProfiles.map((p) => ({
-    name: p.name,
-    role: p.role,
-    domain: p.domain,
-    description: p.description,
-    technologies: p.technologies
-  }));
-  const orphanNames = orphans.map((p) => p.name);
-  const userPrompt = `The following repos have NO detected connections to any other repo:
-${JSON.stringify(orphanNames, null, 2)}
-
-Here are profiles of those repos and their domain neighbors:
-${JSON.stringify(slimProfiles, null, 2)}
-
-Identify likely connections between these orphan repos and any other repo listed above.`;
-  const result = await runClaude(
-    userPrompt,
-    SYSTEM_PROMPT,
-    { model: opts?.model, timeoutMs: 6e5 }
-  );
-  const inferred = parseJsonArray(result.result);
-  const profileNames = new Set(profiles.map((p) => p.name));
-  return inferred.filter(
-    (e) => e.confidence >= 0.6 && profileNames.has(e.source) && profileNames.has(e.target) && e.source !== e.target
-  ).map((e) => ({
-    sourceRepo: e.source,
-    sourceNode: "inferred",
-    targetRepo: e.target,
-    targetNode: "inferred",
-    edgeType: toEdgeType(e.type),
-    evidence: `[LLM-inferred] ${e.evidence}`,
-    confidence: Math.round(e.confidence * 100) / 100
-  }));
-}
-async function inferServiceMesh(profiles, opts) {
-  const progress = opts?.onProgress ?? (() => {
-  });
-  progress(`Matching endpoints across ${profiles.length} repos...`);
-  const deterministicEdges = matchEndpoints(profiles);
-  progress(`Phase A: Found ${deterministicEdges.length} deterministic edges.`);
-  const connectedRepos = /* @__PURE__ */ new Set();
-  for (const edge of deterministicEdges) {
-    connectedRepos.add(edge.sourceRepo);
-    connectedRepos.add(edge.targetRepo);
-  }
-  const orphanCount = profiles.filter((p) => !connectedRepos.has(p.name)).length;
-  let llmEdges = [];
-  if (orphanCount > 0 && opts?.skipLlm !== true) {
-    progress(`Phase B: ${orphanCount} orphan repo(s) detected. Inferring connections via LLM...`);
-    try {
-      llmEdges = await inferOrphanConnections(profiles, deterministicEdges, {
-        model: opts?.model
-      });
-      progress(`Phase B: Inferred ${llmEdges.length} additional edges.`);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      progress(`Phase B: LLM inference failed \u2014 ${message}. Continuing with deterministic edges only.`);
-    }
-  } else if (orphanCount === 0) {
-    progress("Phase B: No orphan repos \u2014 skipping LLM inference.");
-  } else {
-    progress("Phase B: Skipped (skipLlm=true).");
-  }
-  const allEdges = [...deterministicEdges, ...llmEdges];
-  const deduped = deduplicateEdges(allEdges);
-  progress(`Service mesh: ${deduped.length} total edges (${deterministicEdges.length} deterministic, ${llmEdges.length} LLM-inferred).`);
-  return deduped;
-}
-function deduplicateEdges(edges) {
-  const map = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    const key = [
-      edge.sourceRepo,
-      edge.targetRepo,
-      edge.edgeType,
-      normalizeIdentifier(edge.sourceNode),
-      normalizeIdentifier(edge.targetNode)
-    ].join("::");
-    const existing = map.get(key);
-    if (!existing || edge.confidence > existing.confidence) {
-      map.set(key, edge);
-    }
-  }
-  return Array.from(map.values());
-}
-export {
-  identifierSimilarity,
-  inferOrphanConnections,
-  inferServiceMesh,
-  matchEndpoints,
-  normalizeIdentifier
-};

package/dist/core/structural-hasher.js

@@ -1,316 +0,0 @@
-import { createHash } from "node:crypto";
-const STRING_LITERAL_RE = /(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g;
-const LINE_COMMENT_RE = /\/\/.*$/gm;
-const HASH_COMMENT_RE = /#.*$/gm;
-const BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
-const PYTHON_DOCSTRING_RE = /"""[\s\S]*?"""|'''[\s\S]*?'''/g;
-const HASH_COMMENT_LANGS = /* @__PURE__ */ new Set(["python", "ruby", "bash", "shell", "yaml"]);
-const SLASH_COMMENT_LANGS = /* @__PURE__ */ new Set([
-  "typescript",
-  "javascript",
-  "tsx",
-  "jsx",
-  "go",
-  "rust",
-  "java",
-  "c",
-  "cpp",
-  "csharp",
-  "swift",
-  "kotlin",
-  "scala",
-  "dart",
-  "php"
-]);
-function stripComments(content, language) {
-  const strings = [];
-  let protected_ = content.replace(STRING_LITERAL_RE, (match) => {
-    strings.push(match);
-    return `__STR_${strings.length - 1}__`;
-  });
-  if (language === "python") {
-    protected_ = protected_.replace(PYTHON_DOCSTRING_RE, "");
-  }
-  if (SLASH_COMMENT_LANGS.has(language) || language === "css") {
-    protected_ = protected_.replace(BLOCK_COMMENT_RE, "");
-  }
-  if (SLASH_COMMENT_LANGS.has(language)) {
-    protected_ = protected_.replace(LINE_COMMENT_RE, "");
-  }
-  if (HASH_COMMENT_LANGS.has(language)) {
-    protected_ = protected_.replace(HASH_COMMENT_RE, "");
-  }
-  protected_ = protected_.replace(/__STR_(\d+)__/g, (_, idx) => strings[Number(idx)]);
-  return protected_;
-}
-function normalizeWhitespace(content) {
-  return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => line.replace(/,\s*$/, "")).map((line) => line.replace(/\s+/g, " ")).join("\n");
-}
-const VAR_DECL_PATTERNS = {
-  typescript: [
-    /\b(const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=/g
-  ],
-  javascript: [
-    /\b(const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=/g
-  ],
-  tsx: [
-    /\b(const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=/g
-  ],
-  jsx: [
-    /\b(const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=/g
-  ],
-  go: [
-    /\b([a-zA-Z_][\w]*)\s*:=/g,
-    /\bvar\s+([a-zA-Z_][\w]*)\b/g
-  ],
-  python: [
-    // Simple assignment (not augmented, not type-annotated attribute)
-    /^(\s*)([a-zA-Z_][\w]*)\s*=/gm
-  ],
-  rust: [
-    /\blet\s+(?:mut\s+)?([a-zA-Z_][\w]*)\s*(?::|=)/g
-  ]
-};
-function normalizeLocalVariables(content, language) {
-  const langKey = language.toLowerCase();
-  const patterns = VAR_DECL_PATTERNS[langKey];
-  if (!patterns) return content;
-  const localNames = [];
-  for (const pattern of patterns) {
-    const re = new RegExp(pattern.source, pattern.flags);
-    let match;
-    while ((match = re.exec(content)) !== null) {
-      const name = match[2] ?? match[1];
-      if (name && !localNames.includes(name) && !isReservedIdentifier(name)) {
-        localNames.push(name);
-      }
-    }
-  }
-  let result = content;
-  for (let i = 0; i < localNames.length; i++) {
-    const name = localNames[i];
-    const nameRe = new RegExp(`\\b${escapeRegex(name)}\\b`, "g");
-    result = result.replace(nameRe, `v${i}`);
-  }
-  return result;
-}
-function isReservedIdentifier(name) {
-  const reserved = /* @__PURE__ */ new Set([
-    // JS/TS
-    "true",
-    "false",
-    "null",
-    "undefined",
-    "this",
-    "super",
-    "return",
-    "if",
-    "else",
-    "for",
-    "while",
-    "do",
-    "switch",
-    "case",
-    "break",
-    "continue",
-    "throw",
-    "try",
-    "catch",
-    "finally",
-    "new",
-    "delete",
-    "typeof",
-    "instanceof",
-    "void",
-    "in",
-    "of",
-    "async",
-    "await",
-    "yield",
-    "import",
-    "export",
-    "default",
-    "from",
-    "as",
-    "class",
-    "extends",
-    "implements",
-    "interface",
-    "type",
-    "enum",
-    "function",
-    // Go
-    "func",
-    "package",
-    "defer",
-    "go",
-    "select",
-    "chan",
-    "map",
-    "range",
-    "struct",
-    "nil",
-    "err",
-    // Python
-    "def",
-    "lambda",
-    "self",
-    "cls",
-    "None",
-    "True",
-    "False",
-    "with",
-    "pass",
-    "raise",
-    "except",
-    "global",
-    "nonlocal",
-    // Rust
-    "fn",
-    "pub",
-    "crate",
-    "mod",
-    "use",
-    "impl",
-    "trait",
-    "where",
-    "Some",
-    "None",
-    "Ok",
-    "Err",
-    "Self"
-  ]);
-  return reserved.has(name);
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function sortOrderIndependentBlocks(content, language) {
-  let result = content;
-  result = result.replace(
-    /import\s*\{([^}]+)\}\s*from/g,
-    (_match, specifiers) => {
-      const sorted = specifiers.split(",").map((s) => s.trim()).filter((s) => s.length > 0).sort().join(", ");
-      return `import { ${sorted} } from`;
-    }
-  );
-  if (["typescript", "javascript", "tsx", "jsx", "go", "rust"].includes(language)) {
-    result = sortBracedBlocks(result, /\b(?:interface|type\s+\w+\s*=|enum)\s+\w+[^{]*\{/g);
-  }
-  return result;
-}
-function sortBracedBlocks(content, blockStartRe) {
-  const re = new RegExp(blockStartRe.source, blockStartRe.flags);
-  let result = content;
-  let match;
-  const replacements = [];
-  while ((match = re.exec(result)) !== null) {
-    const openBrace = result.indexOf("{", match.index + match[0].length - 1);
-    if (openBrace === -1) continue;
-    let depth = 1;
-    let pos = openBrace + 1;
-    while (pos < result.length && depth > 0) {
-      if (result[pos] === "{") depth++;
-      else if (result[pos] === "}") depth--;
-      pos++;
-    }
-    if (depth !== 0) continue;
-    const closeBrace = pos - 1;
-    const interior = result.slice(openBrace + 1, closeBrace);
-    if (interior.includes("{")) continue;
-    const lines = interior.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
-    if (lines.length <= 1) continue;
-    const sorted = lines.sort().join("\n");
-    replacements.push({
-      start: openBrace + 1,
-      end: closeBrace,
-      replacement: "\n" + sorted + "\n"
-    });
-  }
-  for (const r of replacements.sort((a, b) => b.start - a.start)) {
-    result = result.slice(0, r.start) + r.replacement + result.slice(r.end);
-  }
-  return result;
-}
-function canonicalize(content, language) {
-  let result = content;
-  result = stripComments(result, language);
-  result = normalizeWhitespace(result);
-  result = normalizeLocalVariables(result, language);
-  result = sortOrderIndependentBlocks(result, language);
-  result = normalizeWhitespace(result);
-  return result;
-}
-function computeStructuralHash(content, language) {
-  const canonical = canonicalize(content, language);
-  const hash = createHash("sha256").update(canonical).digest("hex");
-  return { hash, canonicalSize: canonical.length };
-}
-function computeStructuralHashes(chunks) {
-  const hashes = /* @__PURE__ */ new Map();
-  const dedupGroups = /* @__PURE__ */ new Map();
-  for (const chunk of chunks) {
-    const { hash } = computeStructuralHash(chunk.content, chunk.language);
-    hashes.set(chunk.id, hash);
-    const group = dedupGroups.get(hash);
-    if (group) {
-      group.push(chunk.id);
-    } else {
-      dedupGroups.set(hash, [chunk.id]);
-    }
-  }
-  let duplicateCount = 0;
-  for (const group of Array.from(dedupGroups.values())) {
-    if (group.length > 1) {
-      duplicateCount += group.length - 1;
-    }
-  }
-  return {
-    hashes,
-    dedupGroups,
-    duplicateCount,
-    uniqueCount: chunks.length - duplicateCount
-  };
-}
-const CHARS_PER_TOKEN = 4;
-function deduplicateByStructure(chunks) {
-  const hashMap = /* @__PURE__ */ new Map();
-  for (const chunk of chunks) {
-    const hash = chunk.structuralHash ?? computeStructuralHash(chunk.content, chunk.language).hash;
-    hashMap.set(chunk.id, hash);
-  }
-  const groups = /* @__PURE__ */ new Map();
-  for (const chunk of chunks) {
-    const hash = hashMap.get(chunk.id);
-    const group = groups.get(hash);
-    if (group) {
-      group.push(chunk);
-    } else {
-      groups.set(hash, [chunk]);
-    }
-  }
-  const unique = [];
-  const duplicates = [];
-  let savedChars = 0;
-  for (const group of Array.from(groups.values())) {
-    const sorted = [...group].sort((a, b) => a.id.localeCompare(b.id));
-    unique.push(sorted[0]);
-    for (let i = 1; i < sorted.length; i++) {
-      duplicates.push(sorted[i]);
-      savedChars += sorted[i].content.length;
-    }
-  }
-  return {
-    unique,
-    duplicates,
-    savings: {
-      chunks: duplicates.length,
-      estimatedTokens: Math.round(savedChars / CHARS_PER_TOKEN)
-    }
-  };
-}
-export {
-  computeStructuralHash,
-  computeStructuralHashes,
-  deduplicateByStructure
-};