@esankhan3/code-search-mcp 0.0.2 → 0.1.0

package/dist/core/chunker.js

@@ -1,368 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFileSync, existsSync } from "node:fs";
-import { join, relative, extname, basename, dirname } from "node:path";
-import { SOURCE_EXTENSIONS, walkDir, langFromExt, extractImports } from "./file-walker.js";
-function tsPatterns() {
-  return [
-    {
-      regex: /^export\s+function\s+/,
-      entityType: "function",
-      nameExtractor: (l) => l.match(/^export\s+function\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^export\s+class\s+/,
-      entityType: "class",
-      nameExtractor: (l) => l.match(/^export\s+class\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^export\s+const\s+/,
-      entityType: "function",
-      nameExtractor: (l) => l.match(/^export\s+const\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^function\s+/,
-      entityType: "function",
-      nameExtractor: (l) => l.match(/^function\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^class\s+/,
-      entityType: "class",
-      nameExtractor: (l) => l.match(/^class\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^interface\s+/,
-      entityType: "interface",
-      nameExtractor: (l) => l.match(/^interface\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^type\s+/,
-      entityType: "type",
-      nameExtractor: (l) => l.match(/^type\s+(\w+)/)?.[1]
-    }
-  ];
-}
-function pyPatterns() {
-  return [
-    {
-      regex: /^def\s+/,
-      entityType: "function",
-      nameExtractor: (l) => l.match(/^def\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^class\s+/,
-      entityType: "class",
-      nameExtractor: (l) => l.match(/^class\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^async\s+def\s+/,
-      entityType: "function",
-      nameExtractor: (l) => l.match(/^async\s+def\s+(\w+)/)?.[1]
-    }
-  ];
-}
-function goPatterns() {
-  return [
-    {
-      regex: /^func\s+/,
-      entityType: "function",
-      nameExtractor: (l) => l.match(/^func\s+(?:\([^)]*\)\s+)?(\w+)/)?.[1]
-    },
-    {
-      regex: /^type\s+\w+\s+struct/,
-      entityType: "class",
-      nameExtractor: (l) => l.match(/^type\s+(\w+)\s+struct/)?.[1]
-    },
-    {
-      regex: /^type\s+\w+\s+interface/,
-      entityType: "interface",
-      nameExtractor: (l) => l.match(/^type\s+(\w+)\s+interface/)?.[1]
-    }
-  ];
-}
-function rsPatterns() {
-  return [
-    {
-      regex: /^(pub\s+)?fn\s+/,
-      entityType: "function",
-      nameExtractor: (l) => l.match(/fn\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^(pub\s+)?struct\s+/,
-      entityType: "class",
-      nameExtractor: (l) => l.match(/struct\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^impl\s+/,
-      entityType: "class",
-      nameExtractor: (l) => l.match(/^impl\s+(?:<[^>]+>\s+)?(\w+)/)?.[1]
-    },
-    {
-      regex: /^(pub\s+)?trait\s+/,
-      entityType: "interface",
-      nameExtractor: (l) => l.match(/trait\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^(pub\s+)?enum\s+/,
-      entityType: "type",
-      nameExtractor: (l) => l.match(/enum\s+(\w+)/)?.[1]
-    }
-  ];
-}
-function javaPatterns() {
-  return [
-    {
-      regex: /^public\s+class\s+/,
-      entityType: "class",
-      nameExtractor: (l) => l.match(/class\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^public\s+void\s+/,
-      entityType: "method",
-      nameExtractor: (l) => l.match(/void\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^private\s+void\s+/,
-      entityType: "method",
-      nameExtractor: (l) => l.match(/void\s+(\w+)/)?.[1]
-    },
-    {
-      regex: /^public\s+static\s+/,
-      entityType: "method",
-      nameExtractor: (l) => l.match(/static\s+\w+\s+(\w+)/)?.[1]
-    }
-  ];
-}
-function patternsForLanguage(lang) {
-  switch (lang) {
-    case "typescript":
-    case "javascript":
-      return tsPatterns();
-    case "python":
-      return pyPatterns();
-    case "go":
-      return goPatterns();
-    case "rust":
-      return rsPatterns();
-    case "java":
-      return javaPatterns();
-    default:
-      return tsPatterns();
-  }
-}
-function chunkId(filePath, startLine, endLine) {
-  return createHash("sha256").update(`${filePath}${startLine}${endLine}`).digest("hex").slice(0, 16);
-}
-function extractExports(content, lang) {
-  const exports = [];
-  if (lang === "typescript" || lang === "javascript") {
-    const re = /export\s+(?:default\s+)?(?:function|class|const|let|var|interface|type|enum)\s+(\w+)/g;
-    let m;
-    while ((m = re.exec(content)) !== null) {
-      exports.push(m[1]);
-    }
-  }
-  return exports;
-}
-function buildContextPrefix(relPath, lang, imports) {
-  const commentPrefix = lang === "python" ? "#" : "//";
-  const moduleName = dirname(relPath).split("/").filter(Boolean).pop() ?? basename(relPath);
-  const lines = [
-    `${commentPrefix} File: ${relPath}`,
-    `${commentPrefix} Module: ${moduleName}`
-  ];
-  if (imports.length > 0) {
-    const maxImportChars = 150;
-    const importStr = imports.join(", ");
-    const capped = importStr.length > maxImportChars ? importStr.slice(0, maxImportChars) + "..." : importStr;
-    lines.push(`${commentPrefix} Imports: ${capped}`);
-  }
-  return lines.join("\n");
-}
-function contextualizedTokens(contextPrefix, content) {
-  return Math.ceil((contextPrefix.length + 1 + content.length) / 4);
-}
-function splitOversizedContent(contentLines, maxContentChars) {
-  const parts = [];
-  let current = [];
-  let currentLen = 0;
-  for (const line of contentLines) {
-    const lineLen = line.length + 1;
-    if (lineLen > maxContentChars) {
-      if (current.length > 0) {
-        parts.push(current.join("\n"));
-        current = [];
-        currentLen = 0;
-      }
-      parts.push(line.slice(0, maxContentChars));
-      continue;
-    }
-    if (currentLen + lineLen > maxContentChars && current.length > 0) {
-      parts.push(current.join("\n"));
-      current = [];
-      currentLen = 0;
-    }
-    current.push(line);
-    currentLen += lineLen;
-  }
-  if (current.length > 0) {
-    parts.push(current.join("\n"));
-  }
-  return parts;
-}
-function chunkFile(filePath, repoPath, repoName, project, maxTokens) {
-  let raw;
-  try {
-    raw = readFileSync(filePath, "utf-8");
-  } catch {
-    return [];
-  }
-  const relPath = relative(repoPath, filePath);
-  const ext = extname(filePath);
-  const lang = langFromExt(ext);
-  const lines = raw.split("\n");
-  const patterns = patternsForLanguage(lang);
-  const fileImports = extractImports(lines, lang);
-  const contextPrefix = buildContextPrefix(relPath, lang, fileImports);
-  const prefixTokens = Math.ceil(contextPrefix.length / 4) + 1;
-  const maxContentTokens = maxTokens - prefixTokens;
-  const maxContentChars = maxContentTokens * 4;
-  const boundaries = [];
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trimStart();
-    for (const pat of patterns) {
-      if (pat.regex.test(trimmed)) {
-        boundaries.push({
-          line: i,
-          entityType: pat.entityType,
-          entityName: pat.nameExtractor(trimmed)
-        });
-        break;
-      }
-    }
-  }
-  const chunks = [];
-  const pushChunk = (content, startLine, endLine, entityType, entityName) => {
-    const ctxContent = `${contextPrefix}
-${content}`;
-    const tokens = Math.ceil(ctxContent.length / 4);
-    const id = chunkId(relPath, startLine, endLine);
-    chunks.push({
-      id,
-      filePath: relPath,
-      repoName,
-      project,
-      startLine,
-      endLine,
-      content,
-      contextPrefix,
-      contextualizedContent: ctxContent,
-      language: lang,
-      entityType,
-      entityName,
-      tokens,
-      imports: fileImports,
-      exports: extractExports(content, lang)
-    });
-  };
-  const pushContentWithSplit = (contentLines, startLine, entityType, entityName) => {
-    const content = contentLines.join("\n");
-    if (contextualizedTokens(contextPrefix, content) <= maxTokens) {
-      pushChunk(content, startLine, startLine + contentLines.length - 1, entityType, entityName);
-    } else {
-      const parts = splitOversizedContent(contentLines, maxContentChars);
-      let lineOffset = startLine;
-      for (let p = 0; p < parts.length; p++) {
-        const partLines = parts[p].split("\n").length;
-        const partName = entityName ? `${entityName}$${p + 1}` : void 0;
-        pushChunk(parts[p], lineOffset, lineOffset + partLines - 1, entityType, partName);
-        lineOffset += partLines;
-      }
-    }
-  };
-  if (boundaries.length === 0) {
-    pushContentWithSplit(lines, 1, "module", basename(filePath, ext));
-    return chunks;
-  }
-  if (boundaries[0].line > 0) {
-    const leadLines = lines.slice(0, boundaries[0].line);
-    const content = leadLines.join("\n").trimEnd();
-    if (content.length > 0) {
-      pushContentWithSplit(leadLines, 1, "import", void 0);
-    }
-  }
-  for (let i = 0; i < boundaries.length; i++) {
-    const startLine = boundaries[i].line;
-    const endLine = i + 1 < boundaries.length ? boundaries[i + 1].line - 1 : lines.length - 1;
-    const chunkLines = lines.slice(startLine, endLine + 1);
-    pushContentWithSplit(chunkLines, startLine + 1, boundaries[i].entityType, boundaries[i].entityName);
-  }
-  return chunks;
-}
-async function chunkRepo(repoPath, repoName, project, config, cachedFiles) {
-  const files = [];
-  walkDir(repoPath, files);
-  const allChunks = [];
-  const changedFiles = [];
-  const fileIndex = {};
-  const currentFilePaths = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    const relPath = relative(repoPath, file);
-    currentFilePaths.add(relPath);
-    let contents;
-    try {
-      contents = readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    const contentHash = createHash("sha256").update(contents).digest("hex");
-    if (cachedFiles?.[relPath]?.contentHash === contentHash) {
-      fileIndex[relPath] = cachedFiles[relPath];
-      continue;
-    }
-    changedFiles.push(relPath);
-    const chunks = chunkFile(file, repoPath, repoName, project, config.maxTokens);
-    allChunks.push(...chunks);
-    fileIndex[relPath] = { contentHash, chunkCount: chunks.length };
-  }
-  const deletedFiles = [];
-  if (cachedFiles) {
-    for (const path of Object.keys(cachedFiles)) {
-      if (!currentFilePaths.has(path)) {
-        deletedFiles.push(path);
-      }
-    }
-  }
-  return { chunks: allChunks, changedFiles, deletedFiles, fileIndex };
-}
-async function chunkChangedFiles(repoPath, repoName, project, config, diff) {
-  const allChunks = [];
-  const changedFiles = [];
-  const fileIndex = {};
-  for (const relPath of [...diff.added, ...diff.modified]) {
-    const fullPath = join(repoPath, relPath);
-    if (!existsSync(fullPath)) continue;
-    const ext = extname(fullPath);
-    if (!SOURCE_EXTENSIONS.has(ext)) continue;
-    let contents;
-    try {
-      contents = readFileSync(fullPath, "utf-8");
-    } catch {
-      continue;
-    }
-    changedFiles.push(relPath);
-    const contentHash = createHash("sha256").update(contents).digest("hex");
-    const chunks = chunkFile(fullPath, repoPath, repoName, project, config.maxTokens);
-    allChunks.push(...chunks);
-    fileIndex[relPath] = { contentHash, chunkCount: chunks.length };
-  }
-  return {
-    chunks: allChunks,
-    changedFiles,
-    deletedFiles: [...diff.deleted],
-    fileIndex
-  };
-}
-export {
-  chunkChangedFiles,
-  chunkRepo
-};

package/dist/core/claude-runner.js

@@ -1,173 +0,0 @@
-import { spawn } from "node:child_process";
-import { loadServerConfig } from "./env-config.js";
-async function runClaude(prompt, systemPrompt, opts) {
-  const config = loadServerConfig();
-  if (config.llmMode === "none") {
-    throw new Error("LLM inference disabled (CODE_SEARCH_LLM_MODE=none)");
-  }
-  const model = opts?.model ?? config.llmModel;
-  const timeoutMs = opts?.timeoutMs ?? 6e5;
-  if (config.llmMode === "api") {
-    return runViaApi(prompt, systemPrompt, model, timeoutMs, config);
-  }
-  return runViaCli(prompt, systemPrompt, model, timeoutMs, config.claudeBin);
-}
-function isLlmAvailable() {
-  const config = loadServerConfig();
-  return config.llmMode !== "none";
-}
-function runViaCli(prompt, systemPrompt, model, timeoutMs, claudeBin) {
-  return new Promise((resolve, reject) => {
-    const args = [
-      "-p",
-      prompt,
-      "--system-prompt",
-      systemPrompt,
-      "--output-format",
-      "stream-json",
-      "--verbose",
-      "--model",
-      model,
-      "--permission-mode",
-      "bypassPermissions"
-    ];
-    const proc = spawn(claudeBin, args, {
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env }
-    });
-    proc.stdin?.end();
-    let buffer = "";
-    let fullText = "";
-    let resultData = null;
-    const timer = setTimeout(() => {
-      proc.kill("SIGTERM");
-      reject(new Error(`Claude CLI timed out after ${Math.round(timeoutMs / 1e3)}s`));
-    }, timeoutMs);
-    proc.stdout?.on("data", (data) => {
-      buffer += data.toString();
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          const msg = JSON.parse(trimmed);
-          if (msg.type === "assistant" && msg.message?.content) {
-            for (const block of msg.message.content) {
-              if (block.type === "text" && block.text) {
-                fullText += block.text;
-              }
-            }
-          }
-          if (msg.type === "result") {
-            resultData = {
-              result: msg.result ?? fullText,
-              costUsd: msg.total_cost_usd ?? 0,
-              inputTokens: msg.usage?.input_tokens ?? 0,
-              outputTokens: msg.usage?.output_tokens ?? 0,
-              durationMs: msg.duration_ms ?? 0
-            };
-          }
-        } catch {
-        }
-      }
-    });
-    let stderr = "";
-    proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      if (resultData) {
-        resolve(resultData);
-      } else if (code === 0 && fullText) {
-        resolve({ result: fullText, costUsd: 0, inputTokens: 0, outputTokens: 0, durationMs: 0 });
-      } else {
-        reject(new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`));
-      }
-    });
-  });
-}
-async function runViaApi(prompt, systemPrompt, model, timeoutMs, config) {
-  const startTime = Date.now();
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const isAnthropic = config.llmProvider === "anthropic";
-    const url = isAnthropic ? "https://api.anthropic.com/v1/messages" : `${config.llmBaseUrl ?? "https://api.openai.com"}/v1/chat/completions`;
-    if (!config.llmApiKey) {
-      throw new Error(
-        `CODE_SEARCH_LLM_API_KEY not set. Required for LLM_MODE=api. Set it to your ${config.llmProvider} API key, or use LLM_MODE=cli for Claude CLI, or LLM_MODE=none to disable.`
-      );
-    }
-    let body;
-    let headers;
-    if (isAnthropic) {
-      headers = {
-        "Content-Type": "application/json",
-        "x-api-key": config.llmApiKey,
-        "anthropic-version": "2023-06-01"
-      };
-      body = JSON.stringify({
-        model,
-        max_tokens: 8192,
-        system: [{ type: "text", text: systemPrompt }],
-        messages: [{ role: "user", content: prompt }]
-      });
-    } else {
-      headers = {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${config.llmApiKey}`
-      };
-      body = JSON.stringify({
-        model,
-        max_tokens: 8192,
-        messages: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: prompt }
-        ]
-      });
-    }
-    const response = await fetch(url, {
-      method: "POST",
-      headers,
-      body,
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      const errBody = await response.text().catch(() => "");
-      throw new Error(`LLM API error ${response.status}: ${errBody.slice(0, 500)}`);
-    }
-    const json = await response.json();
-    const durationMs = Date.now() - startTime;
-    if (isAnthropic) {
-      const text = (json.content ?? []).filter((b) => b.type === "text" && b.text).map((b) => b.text).join("");
-      return {
-        result: text,
-        costUsd: 0,
-        inputTokens: json.usage?.input_tokens ?? 0,
-        outputTokens: json.usage?.output_tokens ?? 0,
-        durationMs
-      };
-    } else {
-      const text = json.choices?.[0]?.message?.content ?? "";
-      return {
-        result: text,
-        costUsd: 0,
-        inputTokens: json.usage?.prompt_tokens ?? 0,
-        outputTokens: json.usage?.completion_tokens ?? 0,
-        durationMs
-      };
-    }
-  } finally {
-    clearTimeout(timer);
-  }
-}
-export {
-  isLlmAvailable,
-  runClaude
-};

package/dist/core/config.js

@@ -1,59 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-const DEFAULT_CONFIG = {
-  embedding: { provider: "auto", dimensions: 1024 },
-  chunking: { maxTokens: 500, contextEnrichment: "structural" },
-  retrieval: {
-    maxChunks: 20,
-    maxTokens: 12e3,
-    hybridWeights: { vector: 0.5, bm25: 0.3, graph: 0.2 },
-    reranker: "ollama"
-  },
-  autoIndex: true
-};
-function loadKnowledgeConfig(project) {
-  const anvilHome = process.env.ANVIL_HOME || join(homedir(), ".anvil");
-  const paths = [
-    join(anvilHome, "projects", project, "factory.yaml"),
-    join(anvilHome, "projects", project, "project.yaml")
-  ];
-  for (const p of paths) {
-    if (!existsSync(p)) continue;
-    try {
-      const raw = readFileSync(p, "utf-8");
-      return parseKnowledgeSection(raw);
-    } catch {
-    }
-  }
-  return { ...DEFAULT_CONFIG };
-}
-function parseKnowledgeSection(yaml) {
-  const config = { ...DEFAULT_CONFIG };
-  const providerMatch = yaml.match(/^\s{4}provider:\s+(\S+)/m);
-  if (providerMatch) {
-    config.embedding = { ...config.embedding, provider: providerMatch[1] };
-  }
-  const modelMatch = yaml.match(/^\s{4}model:\s+(\S+)/m);
-  if (modelMatch) config.embedding.model = modelMatch[1];
-  const dimMatch = yaml.match(/^\s{4}dimensions:\s+(\d+)/m);
-  if (dimMatch) config.embedding.dimensions = parseInt(dimMatch[1], 10);
-  const chunkMatch = yaml.match(/^\s{4}max_tokens:\s+(\d+)/m);
-  if (chunkMatch) config.chunking.maxTokens = parseInt(chunkMatch[1], 10);
-  const enrichMatch = yaml.match(/^\s{4}context_enrichment:\s+(\S+)/m);
-  if (enrichMatch) config.chunking.contextEnrichment = enrichMatch[1];
-  const autoMatch = yaml.match(/^\s{2}auto_index:\s+(true|false)/m);
-  if (autoMatch) config.autoIndex = autoMatch[1] === "true";
-  return config;
-}
-function getKnowledgeBasePath(project) {
-  const dataDir = process.env.CODE_SEARCH_DATA_DIR;
-  if (dataDir) return join(dataDir, project);
-  const anvilHome = process.env.ANVIL_HOME || join(homedir(), ".anvil");
-  return join(anvilHome, "knowledge-base", project);
-}
-export {
-  DEFAULT_CONFIG,
-  getKnowledgeBasePath,
-  loadKnowledgeConfig
-};