@esankhan3/code-search-mcp 0.0.1

package/dist/core/workspace-detector.js

@@ -0,0 +1,481 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+function safeRead(filePath) {
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function safeJsonParse(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function safeDirEntries(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+const MANIFEST_REGISTRY = [
+  // ---- Node.js (npm / yarn / pnpm) ----
+  {
+    filename: "package.json",
+    ecosystem: "node",
+    extractName(content) {
+      const pkg = safeJsonParse(content);
+      return pkg?.name ?? null;
+    },
+    extractDeps(content) {
+      const pkg = safeJsonParse(content);
+      if (!pkg) return [];
+      return [
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {}),
+        ...Object.keys(pkg.peerDependencies ?? {})
+      ];
+    },
+    extractWorkspaceGlobs(content) {
+      const pkg = safeJsonParse(content);
+      if (!pkg) return null;
+      if (Array.isArray(pkg.workspaces)) return pkg.workspaces;
+      if (Array.isArray(pkg.workspaces?.packages)) return pkg.workspaces.packages;
+      return null;
+    }
+  },
+  // ---- Rust (Cargo) ----
+  {
+    filename: "Cargo.toml",
+    ecosystem: "rust",
+    extractName(content) {
+      const m = content.match(/\[package\][^[]*?name\s*=\s*"([^"]+)"/s);
+      return m?.[1] ?? null;
+    },
+    extractDeps(content) {
+      const deps = [];
+      const depSection = content.match(/\[dependencies\]([\s\S]*?)(?=\n\[|$)/);
+      if (depSection) {
+        const entries = depSection[1].matchAll(/^(\w[\w-]*)\s*=/gm);
+        for (const m of entries) deps.push(m[1]);
+      }
+      const devSection = content.match(/\[dev-dependencies\]([\s\S]*?)(?=\n\[|$)/);
+      if (devSection) {
+        const entries = devSection[1].matchAll(/^(\w[\w-]*)\s*=/gm);
+        for (const m of entries) deps.push(m[1]);
+      }
+      return deps;
+    },
+    extractWorkspaceGlobs(content) {
+      const ws = content.match(/\[workspace\][^[]*?members\s*=\s*\[([\s\S]*?)\]/);
+      if (!ws) return null;
+      const globs = [...ws[1].matchAll(/"([^"]+)"/g)].map((m) => m[1]);
+      return globs.length > 0 ? globs : null;
+    }
+  },
+  // ---- Go ----
+  {
+    filename: "go.mod",
+    ecosystem: "go",
+    extractName(content) {
+      const m = content.match(/^module\s+(\S+)/m);
+      return m?.[1] ?? null;
+    },
+    extractDeps(content) {
+      const deps = [];
+      const singles = content.matchAll(/^require\s+(\S+)\s+/gm);
+      for (const m of singles) deps.push(m[1]);
+      const blocks = content.matchAll(/require\s*\(([\s\S]*?)\)/g);
+      for (const block of blocks) {
+        const entries = block[1].matchAll(/^\s*(\S+)\s+/gm);
+        for (const m of entries) deps.push(m[1]);
+      }
+      return deps;
+    }
+    // go.mod doesn't declare workspaces — go.work does (handled separately)
+  },
+  // ---- Python (pyproject.toml) ----
+  {
+    filename: "pyproject.toml",
+    ecosystem: "python",
+    extractName(content) {
+      const m = content.match(/\[project\][^[]*?name\s*=\s*"([^"]+)"/s);
+      return m?.[1] ?? null;
+    },
+    extractDeps(content) {
+      const deps = [];
+      const depSection = content.match(/\[project\][^[]*?dependencies\s*=\s*\[([\s\S]*?)\]/s);
+      if (depSection) {
+        const entries = depSection[1].matchAll(/"([a-zA-Z0-9_-]+)[^"]*"/g);
+        for (const m of entries) deps.push(m[1]);
+      }
+      return deps;
+    }
+  },
+  // ---- Python (setup.py) ----
+  {
+    filename: "setup.py",
+    ecosystem: "python",
+    extractName(content) {
+      const m = content.match(/name\s*=\s*['"]([^'"]+)['"]/);
+      return m?.[1] ?? null;
+    },
+    extractDeps(content) {
+      const deps = [];
+      const m = content.match(/install_requires\s*=\s*\[([\s\S]*?)\]/);
+      if (m) {
+        const entries = m[1].matchAll(/['"]([a-zA-Z0-9_-]+)[^'"]*['"]/g);
+        for (const e of entries) deps.push(e[1]);
+      }
+      return deps;
+    }
+  },
+  // ---- Java (Maven) ----
+  {
+    filename: "pom.xml",
+    ecosystem: "java",
+    extractName(content) {
+      const group = content.match(/<groupId>([^<]+)<\/groupId>/);
+      const artifact = content.match(/<artifactId>([^<]+)<\/artifactId>/);
+      if (artifact) return group ? `${group[1]}:${artifact[1]}` : artifact[1];
+      return null;
+    },
+    extractDeps(content) {
+      const deps = [];
+      const depBlocks = content.matchAll(/<dependency>\s*([\s\S]*?)<\/dependency>/g);
+      for (const block of depBlocks) {
+        const g = block[1].match(/<groupId>([^<]+)<\/groupId>/);
+        const a = block[1].match(/<artifactId>([^<]+)<\/artifactId>/);
+        if (a) deps.push(g ? `${g[1]}:${a[1]}` : a[1]);
+      }
+      return deps;
+    },
+    extractWorkspaceGlobs(content) {
+      const modules = [...content.matchAll(/<module>([^<]+)<\/module>/g)].map((m) => m[1]);
+      return modules.length > 0 ? modules : null;
+    }
+  },
+  // ---- Java (Gradle) ----
+  {
+    filename: "build.gradle",
+    ecosystem: "java",
+    extractName(_content, dirName) {
+      return dirName || null;
+    },
+    extractDeps(content) {
+      const deps = [];
+      const entries = content.matchAll(/(?:implementation|api|compileOnly|runtimeOnly)\s+['"]([^'"]+)['"]/g);
+      for (const m of entries) deps.push(m[1].replace(/:[^:]+$/, ""));
+      return deps;
+    }
+  },
+  // ---- .NET (C#/F#) ----
+  {
+    filename: "*.csproj",
+    ecosystem: "dotnet",
+    extractName(content, dirName) {
+      const m = content.match(/<AssemblyName>([^<]+)<\/AssemblyName>/);
+      return m?.[1] ?? dirName ?? null;
+    },
+    extractDeps(content) {
+      const deps = [];
+      const refs = content.matchAll(/<PackageReference\s+Include="([^"]+)"/g);
+      for (const m of refs) deps.push(m[1]);
+      const projRefs = content.matchAll(/<ProjectReference\s+Include="([^"]+)"/g);
+      for (const m of projRefs) deps.push(m[1]);
+      return deps;
+    }
+  },
+  // ---- Elixir (Mix) ----
+  {
+    filename: "mix.exs",
+    ecosystem: "elixir",
+    extractName(content) {
+      const m = content.match(/app:\s*:(\w+)/);
+      return m?.[1] ?? null;
+    },
+    extractDeps(content) {
+      const deps = [];
+      const entries = content.matchAll(/\{:(\w+),/g);
+      for (const m of entries) deps.push(m[1]);
+      return deps;
+    }
+  },
+  // ---- PHP (Composer) ----
+  {
+    filename: "composer.json",
+    ecosystem: "php",
+    extractName(content) {
+      const pkg = safeJsonParse(content);
+      return pkg?.name ?? null;
+    },
+    extractDeps(content) {
+      const pkg = safeJsonParse(content);
+      if (!pkg) return [];
+      return [
+        ...Object.keys(pkg.require ?? {}),
+        ...Object.keys(pkg["require-dev"] ?? {})
+      ];
+    }
+  },
+  // ---- Swift (Package.swift) ----
+  {
+    filename: "Package.swift",
+    ecosystem: "swift",
+    extractName(content) {
+      const m = content.match(/name:\s*"([^"]+)"/);
+      return m?.[1] ?? null;
+    },
+    extractDeps(content) {
+      const deps = [];
+      const entries = content.matchAll(/\.package\s*\([^)]*url:\s*"([^"]+)"/g);
+      for (const m of entries) {
+        const name = m[1].replace(/\.git$/, "").split("/").pop();
+        if (name) deps.push(name);
+      }
+      return deps;
+    }
+  }
+];
+const WORKSPACE_ROOT_CONFIGS = [
+  // pnpm-workspace.yaml
+  {
+    filename: "pnpm-workspace.yaml",
+    extractGlobs(content) {
+      const lines = content.split("\n");
+      const globs = [];
+      let inPackages = false;
+      for (const line of lines) {
+        if (/^packages\s*:/.test(line)) {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages) {
+          const m = line.match(/^\s+-\s+['"]?([^'"#\s]+)['"]?/);
+          if (m) {
+            globs.push(m[1]);
+          } else if (/^\S/.test(line)) {
+            break;
+          }
+        }
+      }
+      return globs.length > 0 ? globs : null;
+    }
+  },
+  // go.work
+  {
+    filename: "go.work",
+    extractGlobs(content) {
+      const globs = [];
+      const singles = content.matchAll(/^use\s+(\.\S+)/gm);
+      for (const m of singles) globs.push(m[1]);
+      const blocks = content.matchAll(/use\s*\(([\s\S]*?)\)/g);
+      for (const block of blocks) {
+        const entries = block[1].matchAll(/^\s*(\.\S+)/gm);
+        for (const m of entries) globs.push(m[1]);
+      }
+      return globs.length > 0 ? globs : null;
+    }
+  },
+  // lerna.json
+  {
+    filename: "lerna.json",
+    extractGlobs(content) {
+      const parsed = safeJsonParse(content);
+      if (Array.isArray(parsed?.packages)) return parsed.packages;
+      return null;
+    }
+  },
+  // settings.gradle (Gradle multi-project)
+  {
+    filename: "settings.gradle",
+    extractGlobs(content) {
+      const includes = [...content.matchAll(/include\s+['"]([^'"]+)['"]/g)].map((m) => m[1]);
+      return includes.length > 0 ? includes.map((i) => i.replace(/^:/, "").replace(/:/g, "/")) : null;
+    }
+  },
+  // settings.gradle.kts
+  {
+    filename: "settings.gradle.kts",
+    extractGlobs(content) {
+      const includes = [...content.matchAll(/include\s*\(\s*"([^"]+)"\s*\)/g)].map((m) => m[1]);
+      return includes.length > 0 ? includes.map((i) => i.replace(/^:/, "").replace(/:/g, "/")) : null;
+    }
+  },
+  // nx.json (Nx workspace — projects are auto-detected from package.json but can be explicit)
+  {
+    filename: "nx.json",
+    extractGlobs(content) {
+      const parsed = safeJsonParse(content);
+      if (!parsed) return null;
+      const layout = parsed.workspaceLayout;
+      const globs = [];
+      if (layout?.appsDir) globs.push(`${layout.appsDir}/*`);
+      if (layout?.libsDir) globs.push(`${layout.libsDir}/*`);
+      return globs.length > 0 ? globs : null;
+    }
+  }
+];
+function expandGlobs(rootPath, globs) {
+  const dirs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const glob of globs) {
+    const cleaned = glob.replace(/^\.\//, "").replace(/\/+$/, "");
+    if (cleaned.endsWith("/**")) {
+      const base = cleaned.slice(0, -3);
+      const searchDir = join(rootPath, base);
+      collectDirsRecursive(searchDir, dirs, seen, 3);
+    } else if (cleaned.endsWith("/*")) {
+      const base = cleaned.slice(0, -2);
+      const searchDir = join(rootPath, base);
+      for (const entry of safeDirEntries(searchDir)) {
+        const full = join(searchDir, entry);
+        if (isDir(full) && !seen.has(full)) {
+          seen.add(full);
+          dirs.push(full);
+        }
+      }
+    } else {
+      const full = join(rootPath, cleaned);
+      if (isDir(full) && !seen.has(full)) {
+        seen.add(full);
+        dirs.push(full);
+      }
+    }
+  }
+  return dirs;
+}
+function collectDirsRecursive(dir, result, seen, maxDepth) {
+  if (maxDepth <= 0) return;
+  for (const entry of safeDirEntries(dir)) {
+    if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === "build") continue;
+    const full = join(dir, entry);
+    if (isDir(full) && !seen.has(full)) {
+      seen.add(full);
+      result.push(full);
+      collectDirsRecursive(full, result, seen, maxDepth - 1);
+    }
+  }
+}
+function findManifestInDir(dir) {
+  const dirName = dir.split("/").pop() ?? "";
+  const entries = new Set(safeDirEntries(dir));
+  for (const desc of MANIFEST_REGISTRY) {
+    if (desc.filename.startsWith("*")) {
+      const ext = desc.filename.slice(1);
+      const match = [...entries].find((e) => e.endsWith(ext));
+      if (match) {
+        const content = safeRead(join(dir, match));
+        if (content) return { descriptor: desc, content, filename: match };
+      }
+    } else if (entries.has(desc.filename)) {
+      const content = safeRead(join(dir, desc.filename));
+      if (content) {
+        const name = desc.extractName(content, dirName);
+        if (name) return { descriptor: desc, content, filename: desc.filename };
+      }
+    }
+  }
+  return null;
+}
+function detectTsconfigAliases(repoPath) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const filename of ["tsconfig.json", "tsconfig.base.json"]) {
+    const content = safeRead(join(repoPath, filename));
+    if (!content) continue;
+    const config = safeJsonParse(content);
+    if (!config?.compilerOptions?.paths) continue;
+    const baseUrl = config.compilerOptions.baseUrl ?? ".";
+    const paths = config.compilerOptions.paths;
+    for (const [alias, targets] of Object.entries(paths)) {
+      if (!Array.isArray(targets) || targets.length === 0) continue;
+      const cleanAlias = alias.replace(/\/\*$/, "");
+      const target = targets[0].replace(/\/\*$/, "");
+      const resolved = relative(repoPath, resolve(repoPath, baseUrl, target));
+      aliases.set(cleanAlias, resolved);
+    }
+  }
+  return aliases;
+}
+function detectWorkspace(repoPath) {
+  const packages = [];
+  const nameToPackage = /* @__PURE__ */ new Map();
+  const discoveredDirs = /* @__PURE__ */ new Set();
+  const allGlobs = [];
+  for (const rootConfig of WORKSPACE_ROOT_CONFIGS) {
+    const content = safeRead(join(repoPath, rootConfig.filename));
+    if (!content) continue;
+    const globs = rootConfig.extractGlobs(content);
+    if (globs) allGlobs.push(...globs);
+  }
+  for (const desc of MANIFEST_REGISTRY) {
+    if (!desc.extractWorkspaceGlobs) continue;
+    if (desc.filename.startsWith("*")) continue;
+    const content = safeRead(join(repoPath, desc.filename));
+    if (!content) continue;
+    const globs = desc.extractWorkspaceGlobs(content);
+    if (globs) allGlobs.push(...globs);
+  }
+  if (allGlobs.length > 0) {
+    const expanded = expandGlobs(repoPath, allGlobs);
+    for (const dir of expanded) discoveredDirs.add(dir);
+  }
+  if (discoveredDirs.size === 0) {
+    const fallbackDirs = [];
+    collectDirsRecursive(repoPath, fallbackDirs, /* @__PURE__ */ new Set(), 3);
+    for (const dir of fallbackDirs) {
+      if (findManifestInDir(dir)) discoveredDirs.add(dir);
+    }
+  }
+  for (const dir of discoveredDirs) {
+    const found = findManifestInDir(dir);
+    if (!found) continue;
+    const { descriptor, content, filename } = found;
+    const dirName = dir.split("/").pop() ?? "";
+    const name = descriptor.extractName(content, dirName);
+    if (!name) continue;
+    const pkg = {
+      name,
+      path: dir,
+      relativePath: relative(repoPath, dir),
+      ecosystem: descriptor.ecosystem,
+      manifestFile: filename,
+      dependencies: descriptor.extractDeps(content)
+    };
+    packages.push(pkg);
+    nameToPackage.set(name, pkg);
+  }
+  const rootManifest = findManifestInDir(repoPath);
+  if (rootManifest) {
+    const { descriptor, content, filename } = rootManifest;
+    const name = descriptor.extractName(content, repoPath.split("/").pop() ?? "");
+    if (name && !nameToPackage.has(name)) {
+      const pkg = {
+        name,
+        path: repoPath,
+        relativePath: ".",
+        ecosystem: descriptor.ecosystem,
+        manifestFile: filename,
+        dependencies: descriptor.extractDeps(content)
+      };
+      packages.push(pkg);
+      nameToPackage.set(name, pkg);
+    }
+  }
+  const pathAliases = detectTsconfigAliases(repoPath);
+  return { repoPath, packages, nameToPackage, pathAliases };
+}
+export {
+  detectTsconfigAliases,
+  detectWorkspace
+};

package/dist/index.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+const args = process.argv.slice(2);
+let mode = "remote";
+let remoteUrl = null;
+let apiKey;
+let source = null;
+let projectName = null;
+let githubToken;
+let force = false;
+let port;
+let transport;
+let authMode;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--remote" && args[i + 1]) {
+    mode = "remote";
+    remoteUrl = args[++i];
+  } else if (args[i] === "--local") {
+    mode = "local";
+    if (args[i + 1] && !args[i + 1].startsWith("--")) {
+      source = args[++i];
+    }
+  } else if (args[i] === "--serve") {
+    mode = "serve";
+  } else if (args[i] === "--api-key" && args[i + 1]) {
+    apiKey = args[++i];
+  } else if (args[i] === "--project" && args[i + 1]) {
+    projectName = args[++i];
+  } else if (args[i] === "--token" && args[i + 1]) {
+    githubToken = args[++i];
+  } else if (args[i] === "--force") {
+    force = true;
+  } else if (args[i] === "--port" && args[i + 1]) {
+    port = args[++i];
+  } else if (args[i] === "--transport" && args[i + 1]) {
+    transport = args[++i];
+  } else if (args[i] === "--auth" && args[i + 1]) {
+    authMode = args[++i];
+  } else if (args[i] === "--help" || args[i] === "-h") {
+    console.error(`
+Code Search MCP \u2014 multi-repo code intelligence via MCP
+
+REMOTE MODE (default \u2014 connects to a deployed server):
+  code-search-mcp                                    Uses CODE_SEARCH_SERVER env
+  code-search-mcp --remote https://server:3100       Explicit server URL
+  code-search-mcp --remote https://server:3100 --api-key sk-xxx
+
+  Environment:
+    CODE_SEARCH_SERVER              Remote server URL
+    CODE_SEARCH_API_KEY             API key for authentication
+
+  Claude Desktop config:
+    {
+      "mcpServers": {
+        "code-search": {
+          "command": "code-search-mcp",
+          "env": {
+            "CODE_SEARCH_SERVER": "https://your-server:3100",
+            "CODE_SEARCH_API_KEY": "your-api-key"
+          }
+        }
+      }
+    }
+
+LOCAL MODE (self-hosted \u2014 indexes repos locally):
+  code-search-mcp --local /path/to/repos             Index local directory
+  code-search-mcp --local github:org-name             Clone from GitHub org
+  code-search-mcp --local --project my-project        Serve existing index
+
+  Options:
+    --project <name>        Project name (default: derived from source)
+    --token <token>         GitHub token (or GITHUB_TOKEN env)
+    --force                 Force full re-index
+
+SERVER MODE (deploy as HTTP service):
+  code-search-mcp --serve                             Start HTTP server
+  code-search-mcp --serve --port 3100 --auth api-key
+
+  Options:
+    --port <port>           HTTP port (default: 3100)
+    --auth <mode>           none | api-key | jwt
+    --transport <mode>      streamable-http | sse
+
+  Environment:
+    CODE_SEARCH_TRANSPORT           streamable-http | sse
+    CODE_SEARCH_PORT                HTTP port (default: 3100)
+    CODE_SEARCH_AUTH_MODE           none | api-key | jwt
+    CODE_SEARCH_AUTH_API_KEYS       Comma-separated API keys
+    CODE_SEARCH_EMBEDDING_PROVIDER  auto | codestral | openai | voyage | ollama | custom
+    CODE_SEARCH_EMBEDDING_API_KEY   Unified embedding API key
+    CODE_SEARCH_DATA_DIR            Data directory override
+`);
+    process.exit(0);
+  } else if (!args[i].startsWith("-")) {
+    const arg = args[i];
+    if (arg.startsWith("http://") || arg.startsWith("https://")) {
+      mode = "remote";
+      remoteUrl = arg;
+    } else {
+      mode = "local";
+      source = arg;
+    }
+  }
+}
+(async () => {
+  try {
+    if (mode === "remote") {
+      const serverUrl = remoteUrl ?? process.env.CODE_SEARCH_SERVER ?? process.env.CODE_SEARCH_REMOTE_URL;
+      const key = apiKey ?? process.env.CODE_SEARCH_API_KEY ?? process.env.CODE_SEARCH_AUTH_API_KEY;
+      if (!serverUrl) {
+        console.error(`[code-search-mcp] No remote server configured.
+
+Set CODE_SEARCH_SERVER environment variable:
+  export CODE_SEARCH_SERVER=https://your-server:3100
+
+Or pass it directly:
+  code-search-mcp --remote https://your-server:3100
+
+For local use (self-hosted with repos on this machine):
+  code-search-mcp --local /path/to/repos
+
+For help:
+  code-search-mcp --help
+`);
+        process.exit(1);
+      }
+      const { startRemoteProxy } = await import("./transports/remote-proxy.js");
+      await startRemoteProxy({ serverUrl, apiKey: key });
+      return;
+    }
+    if (mode === "serve") {
+      if (port) process.env.CODE_SEARCH_PORT = port;
+      if (authMode) process.env.CODE_SEARCH_AUTH_MODE = authMode;
+      process.env.CODE_SEARCH_TRANSPORT = transport === "sse" ? "sse" : "streamable-http";
+      const { startServer: startServer2 } = await import("./server.js");
+      await startServer2(projectName ?? "default", source ? resolve(source) : null);
+      return;
+    }
+    let directoryPath = null;
+    if (source?.startsWith("github:")) {
+      const { cloneOrUpdateOrg } = await import("./sources/github-org.js");
+      const spec = source.replace("github:", "");
+      const slashIdx = spec.indexOf("/");
+      const org = slashIdx > 0 ? spec.slice(0, slashIdx) : spec;
+      const pattern = slashIdx > 0 ? spec.slice(slashIdx + 1) : void 0;
+      if (!projectName) projectName = org;
+      console.error(`[code-search-mcp] Cloning repos from github:${org}${pattern ? `/${pattern}` : ""}...`);
+      const repos = await cloneOrUpdateOrg(org, {
+        pattern,
+        token: githubToken,
+        onProgress: (m) => console.error(m)
+      });
+      console.error(`[code-search-mcp] ${repos.length} repos ready`);
+      const { homedir } = await import("node:os");
+      const { join } = await import("node:path");
+      directoryPath = join(homedir(), ".code-search", org);
+    } else if (source) {
+      directoryPath = resolve(source);
+      if (!existsSync(directoryPath)) {
+        console.error(`[code-search-mcp] Directory not found: ${directoryPath}`);
+        process.exit(1);
+      }
+      if (!projectName) {
+        projectName = directoryPath.split("/").filter(Boolean).pop() || "project";
+      }
+    } else if (!projectName) {
+      directoryPath = process.cwd();
+      projectName = directoryPath.split("/").filter(Boolean).pop() || "project";
+    }
+    const { startServer } = await import("./server.js");
+    await startServer(projectName, directoryPath);
+  } catch (err) {
+    console.error(`[code-search-mcp] Fatal:`, err);
+    process.exit(1);
+  }
+})();