@abdulmunimjemal/codescope 0.1.0

package/dist/cli.js

@@ -0,0 +1,1321 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { mkdirSync } from "fs";
+import { resolve as resolve2 } from "path";
+import pc from "picocolors";
+
+// src/format.ts
+function symbolLine(s) {
+  const loc = `${s.file}:${s.startRow + 1}`;
+  const container = s.container ? `${s.container}.` : "";
+  const exp = s.exported ? "export " : "";
+  const sig = s.signature ? `  \xB7  ${s.signature}` : "";
+  return `${s.kind} ${exp}${container}${s.name} \u2014 ${loc}${sig}`;
+}
+function formatSymbols(rows) {
+  if (rows.length === 0) return "No matching symbols.";
+  return rows.map(symbolLine).join("\n");
+}
+function formatRefs(rows) {
+  if (rows.length === 0) return "No references.";
+  return rows.map((r) => {
+    const where = r.fromSymbol ? `${r.fromSymbol}` : "(top level)";
+    return `${where} \u2192 ${r.name} [${r.kind}] \u2014 ${r.file}:${r.startRow + 1}`;
+  }).join("\n");
+}
+function formatNeighborhood(n) {
+  const lines = [`neighbourhood of ${n.root}:`];
+  lines.push("", "definitions:");
+  if (n.nodes.length === 0) lines.push("  (none indexed)");
+  else for (const s of n.nodes) lines.push(`  ${symbolLine(s)}`);
+  if (n.edges.length > 0) {
+    lines.push("", "call edges:");
+    for (const e of n.edges) lines.push(`  ${e.from} \u2192 ${e.to}`);
+  }
+  if (n.unresolved.length > 0) {
+    lines.push("", `unresolved (referenced, not defined in index): ${n.unresolved.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function formatStats(s) {
+  const kinds = Object.entries(s.byKind).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k}=${n}`).join(" ");
+  const langs = Object.entries(s.byLang).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k}=${n}`).join(" ");
+  return [
+    `files:   ${s.files}`,
+    `symbols: ${s.symbols}  (${kinds || "none"})`,
+    `refs:    ${s.refs}`,
+    `langs:   ${langs || "none"}`
+  ].join("\n");
+}
+
+// src/indexer.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import { relative, resolve, sep } from "path";
+import ignore from "ignore";
+import { glob } from "tinyglobby";
+
+// src/languages.ts
+var JS_CALLS = [
+  { type: "call_expression", fnField: "function", memberTypes: ["member_expression"], memberField: "property" }
+];
+var typescript = {
+  id: "typescript",
+  wasm: "typescript",
+  defs: {
+    function_declaration: { kind: "function" },
+    generator_function_declaration: { kind: "function" },
+    function_signature: { kind: "function" },
+    method_definition: { kind: "method" },
+    method_signature: { kind: "method" },
+    class_declaration: { kind: "class" },
+    abstract_class_declaration: { kind: "class" },
+    interface_declaration: { kind: "interface" },
+    type_alias_declaration: { kind: "type" },
+    enum_declaration: { kind: "enum" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(["variable_declarator", "public_field_definition"]),
+  nestedFunctionsAreMethods: false,
+  callRules: JS_CALLS,
+  importRules: [{ type: "import_statement", field: "source" }],
+  exportTypes: /* @__PURE__ */ new Set(["export_statement"])
+};
+var tsx = { ...typescript, id: "tsx", wasm: "tsx" };
+var javascript = {
+  id: "javascript",
+  wasm: "javascript",
+  defs: {
+    function_declaration: { kind: "function" },
+    generator_function_declaration: { kind: "function" },
+    method_definition: { kind: "method" },
+    class_declaration: { kind: "class" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(["variable_declarator", "field_definition"]),
+  nestedFunctionsAreMethods: false,
+  callRules: JS_CALLS,
+  importRules: [{ type: "import_statement", field: "source" }],
+  exportTypes: /* @__PURE__ */ new Set(["export_statement"])
+};
+var python = {
+  id: "python",
+  wasm: "python",
+  defs: {
+    function_definition: { kind: "function" },
+    class_definition: { kind: "class" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [{ type: "call", fnField: "function", memberTypes: ["attribute"], memberField: "attribute" }],
+  importRules: [
+    { type: "import_statement", childTypes: ["dotted_name", "aliased_import"] },
+    { type: "import_from_statement", field: "module_name" }
+  ],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var go = {
+  id: "go",
+  wasm: "go",
+  defs: {
+    function_declaration: { kind: "function" },
+    method_declaration: { kind: "method" },
+    type_spec: { kind: "class" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [
+    { type: "call_expression", fnField: "function", memberTypes: ["selector_expression"], memberField: "field" }
+  ],
+  importRules: [{ type: "import_spec", field: "path" }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var rust = {
+  id: "rust",
+  wasm: "rust",
+  defs: {
+    function_item: { kind: "function" },
+    struct_item: { kind: "class" },
+    union_item: { kind: "class" },
+    enum_item: { kind: "enum" },
+    trait_item: { kind: "interface" },
+    type_item: { kind: "type" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [
+    {
+      type: "call_expression",
+      fnField: "function",
+      memberTypes: ["field_expression"],
+      memberField: "field",
+      scopedTypes: ["scoped_identifier"],
+      scopedField: "name"
+    }
+  ],
+  importRules: [{ type: "use_declaration", field: "argument" }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var java = {
+  id: "java",
+  wasm: "java",
+  defs: {
+    class_declaration: { kind: "class" },
+    interface_declaration: { kind: "interface" },
+    enum_declaration: { kind: "enum" },
+    record_declaration: { kind: "class" },
+    method_declaration: { kind: "method" },
+    constructor_declaration: { kind: "method" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [{ type: "method_invocation", nameField: "name", receiverField: "object" }],
+  importRules: [{ type: "import_declaration", childTypes: ["scoped_identifier", "identifier"] }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var ruby = {
+  id: "ruby",
+  wasm: "ruby",
+  defs: {
+    method: { kind: "method" },
+    singleton_method: { kind: "method" },
+    class: { kind: "class" },
+    module: { kind: "class" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [{ type: "call", nameField: "method", receiverField: "receiver" }],
+  importRules: [],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var c = {
+  id: "c",
+  wasm: "c",
+  defs: {
+    function_definition: { kind: "function", name: "c_declarator" },
+    struct_specifier: { kind: "class" },
+    union_specifier: { kind: "class" },
+    enum_specifier: { kind: "enum" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [
+    { type: "call_expression", fnField: "function", memberTypes: ["field_expression"], memberField: "field" }
+  ],
+  importRules: [{ type: "preproc_include", field: "path" }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var cpp = {
+  id: "cpp",
+  wasm: "cpp",
+  defs: {
+    function_definition: { kind: "function", name: "c_declarator" },
+    class_specifier: { kind: "class" },
+    struct_specifier: { kind: "class" },
+    enum_specifier: { kind: "enum" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: true,
+  callRules: [
+    { type: "call_expression", fnField: "function", memberTypes: ["field_expression"], memberField: "field" }
+  ],
+  importRules: [{ type: "preproc_include", field: "path" }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var csharp = {
+  id: "csharp",
+  wasm: "c_sharp",
+  defs: {
+    class_declaration: { kind: "class" },
+    struct_declaration: { kind: "class" },
+    interface_declaration: { kind: "interface" },
+    enum_declaration: { kind: "enum" },
+    record_declaration: { kind: "class" },
+    method_declaration: { kind: "method" },
+    constructor_declaration: { kind: "method" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [
+    {
+      type: "invocation_expression",
+      fnField: "function",
+      memberTypes: ["member_access_expression"],
+      memberField: "name"
+    }
+  ],
+  importRules: [{ type: "using_directive", childTypes: ["identifier", "qualified_name"] }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var php = {
+  id: "php",
+  wasm: "php",
+  defs: {
+    function_definition: { kind: "function" },
+    method_declaration: { kind: "method" },
+    class_declaration: { kind: "class" },
+    interface_declaration: { kind: "interface" },
+    trait_declaration: { kind: "class" },
+    enum_declaration: { kind: "enum" }
+  },
+  functionBindings: /* @__PURE__ */ new Set(),
+  nestedFunctionsAreMethods: false,
+  callRules: [
+    { type: "function_call_expression", fnField: "function" },
+    { type: "member_call_expression", nameField: "name", forceKind: "method" },
+    { type: "scoped_call_expression", nameField: "name", forceKind: "method" }
+  ],
+  importRules: [{ type: "namespace_use_declaration", childTypes: ["namespace_use_clause"] }],
+  exportTypes: /* @__PURE__ */ new Set()
+};
+var LANGUAGES = {
+  typescript,
+  tsx,
+  javascript,
+  python,
+  go,
+  rust,
+  java,
+  ruby,
+  c,
+  cpp,
+  csharp,
+  php
+};
+var EXT_TO_LANG = {
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "tsx",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascript",
+  ".py": "python",
+  ".pyi": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".rb": "ruby",
+  ".c": "c",
+  ".h": "c",
+  ".cc": "cpp",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".hh": "cpp",
+  ".cs": "csharp",
+  ".php": "php"
+};
+var SUPPORTED_EXTENSIONS = Object.keys(EXT_TO_LANG);
+function languageForPath(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot === -1) return void 0;
+  const ext = path.slice(dot).toLowerCase();
+  const id = EXT_TO_LANG[ext];
+  return id ? LANGUAGES[id] : void 0;
+}
+
+// src/parser.ts
+import { createRequire } from "module";
+import Parser from "web-tree-sitter";
+var require2 = createRequire(import.meta.url);
+var initPromise = null;
+var parserCache = /* @__PURE__ */ new Map();
+function grammarPath(wasm) {
+  return require2.resolve(`tree-sitter-wasms/out/tree-sitter-${wasm}.wasm`);
+}
+async function ensureInit() {
+  if (!initPromise) initPromise = Parser.init();
+  await initPromise;
+}
+async function getParser(lang) {
+  const cached = parserCache.get(lang.id);
+  if (cached) return cached;
+  await ensureInit();
+  const language = await Parser.Language.load(grammarPath(lang.wasm));
+  const parser = new Parser();
+  parser.setLanguage(language);
+  parserCache.set(lang.id, parser);
+  return parser;
+}
+var FUNCTION_VALUE_TYPES = /* @__PURE__ */ new Set([
+  "arrow_function",
+  "function",
+  "function_expression",
+  "generator_function"
+]);
+async function parseSource(langId, source) {
+  const lang = LANGUAGES[langId];
+  if (!lang) throw new Error(`Unknown language: ${langId}`);
+  const parser = await getParser(lang);
+  const tree = parser.parse(source);
+  const symbols = [];
+  const refs = [];
+  if (tree?.rootNode) {
+    walk(tree.rootNode, lang, null, null, symbols, refs);
+    tree.delete();
+  }
+  return { lang: lang.id, symbols, refs };
+}
+function walk(node, lang, container, containerKind, symbols, refs) {
+  let childContainer = container;
+  let childContainerKind = containerKind;
+  const rule = classify(node, lang);
+  const call = lang.callRules.find((r) => r.type === node.type);
+  const imp = lang.importRules.find((r) => r.type === node.type);
+  if (rule) {
+    const sym = buildSymbol(node, rule, container, containerKind, lang);
+    if (sym) {
+      symbols.push(sym);
+      childContainer = sym.name;
+      childContainerKind = sym.kind;
+    }
+  } else if (call) {
+    const ref = extractCall(node, call, container);
+    if (ref) refs.push(ref);
+  } else if (imp) {
+    for (const ref of extractImports(node, imp, container)) refs.push(ref);
+  }
+  for (const child of node.namedChildren) {
+    walk(child, lang, childContainer, childContainerKind, symbols, refs);
+  }
+}
+function classify(node, lang) {
+  const direct = lang.defs[node.type];
+  if (direct) return direct;
+  if (lang.functionBindings.has(node.type)) {
+    const value = node.childForFieldName("value");
+    if (value && FUNCTION_VALUE_TYPES.has(value.type)) return { kind: "function" };
+  }
+  return null;
+}
+function buildSymbol(node, rule, container, containerKind, lang) {
+  const name = symbolName(node, rule.name ?? "field");
+  if (!name) return null;
+  let kind = rule.kind;
+  if (kind === "function" && lang.nestedFunctionsAreMethods && containerKind === "class") {
+    kind = "method";
+  }
+  return {
+    name,
+    kind,
+    container,
+    exported: isExported(node, lang),
+    signature: signatureOf(node),
+    startRow: node.startPosition.row,
+    startCol: node.startPosition.column,
+    endRow: node.endPosition.row,
+    endCol: node.endPosition.column,
+    startByte: node.startIndex,
+    endByte: node.endIndex
+  };
+}
+function symbolName(node, strategy) {
+  if (strategy === "c_declarator") return cDeclaratorName(node);
+  return node.childForFieldName("name")?.text ?? null;
+}
+function cDeclaratorName(node) {
+  let decl = node.childForFieldName("declarator");
+  for (let i = 0; decl && i < 10; i++) {
+    if (decl.type === "identifier" || decl.type === "field_identifier") return decl.text;
+    if (decl.type === "qualified_identifier" || decl.type === "destructor_name") {
+      return decl.childForFieldName("name")?.text ?? decl.text;
+    }
+    const inner = decl.childForFieldName("declarator");
+    if (!inner) break;
+    decl = inner;
+  }
+  return null;
+}
+function isExported(node, lang) {
+  if (lang.exportTypes.size === 0) return false;
+  let cur = node.parent;
+  for (let i = 0; cur && i < 2; i++) {
+    if (lang.exportTypes.has(cur.type)) return true;
+    cur = cur.parent;
+  }
+  return false;
+}
+function signatureOf(node) {
+  const body = node.childForFieldName("body");
+  const raw = body ? node.text.slice(0, body.startIndex - node.startIndex) : node.text;
+  const text = raw.replace(/\s+/g, " ").trim();
+  if (!text) return null;
+  return text.length > 240 ? `${text.slice(0, 239)}\u2026` : text;
+}
+function extractCall(node, rule, container) {
+  let name = null;
+  let kind = "call";
+  if (rule.nameField) {
+    name = node.childForFieldName(rule.nameField)?.text ?? null;
+    if (rule.receiverField && node.childForFieldName(rule.receiverField)) kind = "method";
+  } else if (rule.fnField) {
+    const fn = node.childForFieldName(rule.fnField);
+    if (fn) {
+      if (rule.memberTypes?.includes(fn.type)) {
+        name = fn.childForFieldName(rule.memberField ?? "")?.text ?? null;
+        kind = "method";
+      } else if (rule.scopedTypes?.includes(fn.type)) {
+        name = fn.childForFieldName(rule.scopedField ?? "")?.text ?? null;
+      } else if (fn.type === "identifier" || fn.type === "name") {
+        name = fn.text;
+      }
+    }
+  }
+  if (rule.forceKind) kind = rule.forceKind;
+  if (!name) return null;
+  return {
+    fromSymbol: container,
+    name,
+    kind,
+    startRow: node.startPosition.row,
+    startCol: node.startPosition.column
+  };
+}
+function extractImports(node, rule, container) {
+  const out = [];
+  const add = (spec) => {
+    const name = spec ? unquote(spec) : "";
+    if (name) {
+      out.push({
+        fromSymbol: container,
+        name,
+        kind: "import",
+        startRow: node.startPosition.row,
+        startCol: node.startPosition.column
+      });
+    }
+  };
+  if (rule.field) {
+    add(node.childForFieldName(rule.field)?.text);
+  }
+  if (rule.childTypes) {
+    for (const child of node.namedChildren) {
+      if (!rule.childTypes.includes(child.type)) continue;
+      if (child.type === "aliased_import") add(child.childForFieldName("name")?.text);
+      else add(child.text);
+    }
+  }
+  return out;
+}
+function unquote(text) {
+  const t = text.trim();
+  if (t.length >= 2) {
+    const first = t[0];
+    const last = t[t.length - 1];
+    if ((first === '"' || first === "'" || first === "`") && first === last) {
+      return t.slice(1, -1);
+    }
+    if (first === "<" && last === ">") return t.slice(1, -1);
+  }
+  return t;
+}
+
+// src/indexer.ts
+var DEFAULT_IGNORES = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/.codescope/**",
+  "**/.next/**",
+  "**/out/**",
+  "**/target/**",
+  "**/.venv/**",
+  "**/venv/**",
+  "**/vendor/**",
+  "**/__pycache__/**"
+];
+var Indexer = class {
+  constructor(store, root) {
+    this.store = store;
+    this.root = resolve(root);
+  }
+  store;
+  root;
+  /** Index every supported, non-ignored file and prune deleted ones. */
+  async indexAll(opts = {}) {
+    const start = Date.now();
+    const result = {
+      indexed: 0,
+      skipped: 0,
+      removed: 0,
+      errors: [],
+      durationMs: 0
+    };
+    const files = await this.listSourceFiles(opts);
+    const present = /* @__PURE__ */ new Set();
+    for (const abs of files) {
+      present.add(this.rel(abs));
+      try {
+        const outcome = await this.indexFile(abs, start);
+        if (outcome === "indexed") result.indexed++;
+        else if (outcome === "skipped") result.skipped++;
+      } catch (err) {
+        result.errors.push({ file: this.rel(abs), error: errorMessage(err) });
+      }
+    }
+    for (const known of this.store.listFiles()) {
+      if (!present.has(known) && this.store.removeFile(known)) result.removed++;
+    }
+    result.durationMs = Date.now() - start;
+    return result;
+  }
+  /** Index a single file by absolute path. Cheap when the content is unchanged. */
+  async indexFile(abs, now = Date.now()) {
+    const lang = languageForPath(abs);
+    if (!lang) return "unsupported";
+    const rel = this.rel(abs);
+    const content = await readFile(abs, "utf8");
+    const hash = sha1(content);
+    if (this.store.getFileHash(rel) === hash) return "skipped";
+    const mtime = await fileMtime(abs, now);
+    const { symbols, refs } = await parseSource(lang.id, content);
+    this.store.replaceFile(
+      { path: rel, lang: lang.id, hash, size: content.length, mtime },
+      symbols,
+      refs,
+      now
+    );
+    return "indexed";
+  }
+  /** Drop a file from the graph by absolute path. */
+  removeFile(abs) {
+    return this.store.removeFile(this.rel(abs));
+  }
+  /** Repo-relative, POSIX-separated path used as the stable graph key. */
+  rel(abs) {
+    return relative(this.root, resolve(abs)).split(sep).join("/");
+  }
+  async listSourceFiles(opts) {
+    const patterns = SUPPORTED_EXTENSIONS.map((ext) => `**/*${ext}`);
+    const files = await glob(patterns, {
+      cwd: this.root,
+      absolute: true,
+      ignore: [...DEFAULT_IGNORES, ...opts.ignore ?? []],
+      dot: false
+    });
+    if (opts.gitignore === false) return files;
+    const ig = this.loadGitignore();
+    if (!ig) return files;
+    return files.filter((f) => {
+      const rel = this.rel(f);
+      return rel.length > 0 && !ig.ignores(rel);
+    });
+  }
+  loadGitignore() {
+    try {
+      const content = readFileSync(resolve(this.root, ".gitignore"), "utf8");
+      return ignore().add(content);
+    } catch {
+      return null;
+    }
+  }
+};
+function sha1(content) {
+  return createHash("sha1").update(content).digest("hex");
+}
+async function fileMtime(abs, fallback) {
+  try {
+    const st = await stat(abs);
+    return Math.floor(st.mtimeMs);
+  } catch {
+    return fallback;
+  }
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/mcp.ts
+var KIND = z.enum(["function", "method", "class", "interface", "type", "enum", "variable"]);
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function createServer(store) {
+  const server = new McpServer({ name: "codescope", version: VERSION });
+  server.registerTool(
+    "search_symbols",
+    {
+      title: "Search code symbols",
+      description: "Fuzzy-search definitions (functions, classes, methods, interfaces, types, enums) by name across the whole repo. Prefer this over grep/glob/read when locating where something is defined \u2014 it returns exact file:line locations and signatures in a few tokens.",
+      inputSchema: {
+        query: z.string().describe("substring to match against symbol names"),
+        kind: KIND.optional().describe("restrict to one symbol kind"),
+        limit: z.number().int().positive().max(500).optional()
+      }
+    },
+    async ({ query, kind, limit }) => textResult(formatSymbols(store.searchSymbols(query, { kind, limit })))
+  );
+  server.registerTool(
+    "get_symbol",
+    {
+      title: "Get a symbol definition",
+      description: "Look up a definition by its exact name. Returns each matching definition's kind, file:line, and signature. Use this to jump straight to a definition instead of reading files.",
+      inputSchema: {
+        name: z.string().describe("exact symbol name"),
+        limit: z.number().int().positive().max(500).optional()
+      }
+    },
+    async ({ name, limit }) => textResult(formatSymbols(store.getSymbol(name, { limit })))
+  );
+  server.registerTool(
+    "find_callers",
+    {
+      title: "Find callers",
+      description: "List the symbols that call a given function/method name, with file:line. Use this to trace impact and call sites without scanning files.",
+      inputSchema: {
+        name: z.string().describe("the called function/method name"),
+        limit: z.number().int().positive().max(500).optional()
+      }
+    },
+    async ({ name, limit }) => textResult(formatRefs(store.findCallers(name, { limit })))
+  );
+  server.registerTool(
+    "find_references",
+    {
+      title: "Find references",
+      description: "List all references (calls and imports) to a name. Useful for understanding how widely something is used.",
+      inputSchema: {
+        name: z.string(),
+        kind: z.enum(["call", "method", "import"]).optional(),
+        limit: z.number().int().positive().max(500).optional()
+      }
+    },
+    async ({ name, kind, limit }) => textResult(formatRefs(store.findReferences(name, { kind, limit })))
+  );
+  server.registerTool(
+    "file_outline",
+    {
+      title: "Outline a file",
+      description: "List every symbol defined in a file, in source order, with signatures. A compact alternative to reading the whole file when you only need its shape.",
+      inputSchema: {
+        path: z.string().describe("repo-relative file path")
+      }
+    },
+    async ({ path }) => textResult(formatSymbols(store.fileOutline(path)))
+  );
+  server.registerTool(
+    "neighborhood",
+    {
+      title: "Call neighbourhood",
+      description: "Return the call neighbourhood around a symbol \u2014 its callers and callees expanded a few hops \u2014 as a compact subgraph. This is the high-leverage tool: it gives you the relevant slice of the codebase for a change without reading dozens of files.",
+      inputSchema: {
+        name: z.string(),
+        depth: z.number().int().min(1).max(5).optional().describe("hops to expand (default 2)"),
+        limit: z.number().int().positive().max(200).optional()
+      }
+    },
+    async ({ name, depth, limit }) => textResult(formatNeighborhood(store.neighborhood(name, { depth, limit })))
+  );
+  server.registerTool(
+    "stats",
+    {
+      title: "Graph stats",
+      description: "Summary counts for the indexed graph (files, symbols, refs, by kind and language).",
+      inputSchema: {}
+    },
+    async () => textResult(formatStats(store.stats()))
+  );
+  return server;
+}
+async function runStdioServer(store) {
+  const server = createServer(store);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/store.ts
+import Database from "better-sqlite3";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS files (
+  id         INTEGER PRIMARY KEY,
+  path       TEXT NOT NULL UNIQUE,
+  lang       TEXT NOT NULL,
+  hash       TEXT NOT NULL,
+  size       INTEGER NOT NULL,
+  mtime      INTEGER NOT NULL,
+  indexed_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS symbols (
+  id         INTEGER PRIMARY KEY,
+  file_id    INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+  name       TEXT NOT NULL,
+  kind       TEXT NOT NULL,
+  container  TEXT,
+  exported   INTEGER NOT NULL DEFAULT 0,
+  signature  TEXT,
+  start_row  INTEGER NOT NULL,
+  start_col  INTEGER NOT NULL,
+  end_row    INTEGER NOT NULL,
+  end_col    INTEGER NOT NULL,
+  start_byte INTEGER NOT NULL,
+  end_byte   INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS refs (
+  id          INTEGER PRIMARY KEY,
+  file_id     INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+  from_symbol TEXT,
+  name        TEXT NOT NULL,
+  kind        TEXT NOT NULL,
+  start_row   INTEGER NOT NULL,
+  start_col   INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_id);
+CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind);
+CREATE INDEX IF NOT EXISTS idx_refs_name ON refs(name);
+CREATE INDEX IF NOT EXISTS idx_refs_file ON refs(file_id);
+CREATE INDEX IF NOT EXISTS idx_refs_from ON refs(from_symbol);
+
+-- Trigram FTS index for fast substring symbol search at scale. Kept in sync
+-- manually (rowid = symbols.id) so it survives the per-file replace/delete path.
+CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(name, tokenize='trigram');
+`;
+var SYMBOL_COLUMNS = `
+  s.id, f.path AS file, s.name, s.kind, s.container, s.exported, s.signature,
+  s.start_row, s.start_col, s.end_row, s.end_col`;
+var GraphStore = class {
+  db;
+  constructor(location = ":memory:") {
+    this.db = new Database(location);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(SCHEMA);
+  }
+  /** The content hash of an already-indexed file, if present. */
+  getFileHash(path) {
+    const row = this.db.prepare("SELECT hash FROM files WHERE path = ?").get(path);
+    return row?.hash;
+  }
+  /** All indexed file paths. */
+  listFiles() {
+    return this.db.prepare("SELECT path FROM files ORDER BY path").all().map((r) => r.path);
+  }
+  /** Insert or replace a file and all of its symbols/refs in one transaction. */
+  replaceFile(meta, symbols, refs, now) {
+    this.transaction(() => {
+      this.dropFtsForFile(meta.path);
+      this.db.prepare("DELETE FROM files WHERE path = ?").run(meta.path);
+      const fileId = Number(
+        this.db.prepare(
+          "INSERT INTO files (path, lang, hash, size, mtime, indexed_at) VALUES (?, ?, ?, ?, ?, ?)"
+        ).run(meta.path, meta.lang, meta.hash, meta.size, meta.mtime, now).lastInsertRowid
+      );
+      const insSym = this.db.prepare(
+        `INSERT INTO symbols
+           (file_id, name, kind, container, exported, signature,
+            start_row, start_col, end_row, end_col, start_byte, end_byte)
+         VALUES (@file_id, @name, @kind, @container, @exported, @signature,
+                 @start_row, @start_col, @end_row, @end_col, @start_byte, @end_byte)`
+      );
+      const insFts = this.db.prepare("INSERT INTO symbols_fts(rowid, name) VALUES (?, ?)");
+      for (const s of symbols) {
+        const symId = insSym.run({
+          file_id: fileId,
+          name: s.name,
+          kind: s.kind,
+          container: s.container,
+          exported: s.exported ? 1 : 0,
+          signature: s.signature,
+          start_row: s.startRow,
+          start_col: s.startCol,
+          end_row: s.endRow,
+          end_col: s.endCol,
+          start_byte: s.startByte,
+          end_byte: s.endByte
+        }).lastInsertRowid;
+        insFts.run(symId, s.name);
+      }
+      const insRef = this.db.prepare(
+        `INSERT INTO refs (file_id, from_symbol, name, kind, start_row, start_col)
+         VALUES (@file_id, @from_symbol, @name, @kind, @start_row, @start_col)`
+      );
+      for (const r of refs) {
+        insRef.run({
+          file_id: fileId,
+          from_symbol: r.fromSymbol,
+          name: r.name,
+          kind: r.kind,
+          start_row: r.startRow,
+          start_col: r.startCol
+        });
+      }
+    });
+  }
+  /** Remove a file and its symbols/refs. Returns true if anything was deleted. */
+  removeFile(path) {
+    return this.transactionResult(() => {
+      this.dropFtsForFile(path);
+      return this.db.prepare("DELETE FROM files WHERE path = ?").run(path).changes > 0;
+    });
+  }
+  /** Remove the FTS rows for a file's current symbols (call before deleting it). */
+  dropFtsForFile(path) {
+    const ids = this.db.prepare(
+      "SELECT s.id FROM symbols s JOIN files f ON f.id = s.file_id WHERE f.path = ?"
+    ).all(path);
+    if (ids.length === 0) return;
+    const del = this.db.prepare("DELETE FROM symbols_fts WHERE rowid = ?");
+    for (const { id } of ids) del.run(id);
+  }
+  // ── Queries ────────────────────────────────────────────────────────────
+  /**
+   * Fuzzy substring search over symbol names. Queries of 3+ characters use the
+   * trigram FTS index (fast at scale); shorter queries fall back to LIKE since
+   * trigram matching needs at least three characters.
+   */
+  searchSymbols(query, opts = {}) {
+    const limit = clampLimit(opts.limit);
+    if (query.trim().length >= 3) {
+      const match = `"${query.replace(/"/g, '""')}"`;
+      const rows2 = opts.kind ? this.db.prepare(
+        `SELECT ${SYMBOL_COLUMNS} FROM symbols_fts ft
+               JOIN symbols s ON s.id = ft.rowid JOIN files f ON f.id = s.file_id
+               WHERE symbols_fts MATCH ? AND s.kind = ?
+               ORDER BY s.exported DESC, length(s.name), s.name LIMIT ?`
+      ).all(match, opts.kind, limit) : this.db.prepare(
+        `SELECT ${SYMBOL_COLUMNS} FROM symbols_fts ft
+               JOIN symbols s ON s.id = ft.rowid JOIN files f ON f.id = s.file_id
+               WHERE symbols_fts MATCH ?
+               ORDER BY s.exported DESC, length(s.name), s.name LIMIT ?`
+      ).all(match, limit);
+      return rows2.map(toSymbolRow);
+    }
+    const like = `%${escapeLike(query)}%`;
+    const rows = opts.kind ? this.db.prepare(
+      `SELECT ${SYMBOL_COLUMNS} FROM symbols s JOIN files f ON f.id = s.file_id
+             WHERE s.name LIKE ? ESCAPE '\\' AND s.kind = ?
+             ORDER BY s.exported DESC, length(s.name), s.name LIMIT ?`
+    ).all(like, opts.kind, limit) : this.db.prepare(
+      `SELECT ${SYMBOL_COLUMNS} FROM symbols s JOIN files f ON f.id = s.file_id
+             WHERE s.name LIKE ? ESCAPE '\\'
+             ORDER BY s.exported DESC, length(s.name), s.name LIMIT ?`
+    ).all(like, limit);
+    return rows.map(toSymbolRow);
+  }
+  /** Exact-name definition lookup. */
+  getSymbol(name, opts = {}) {
+    return this.db.prepare(
+      `SELECT ${SYMBOL_COLUMNS} FROM symbols s JOIN files f ON f.id = s.file_id
+         WHERE s.name = ? ORDER BY s.exported DESC, f.path LIMIT ?`
+    ).all(name, clampLimit(opts.limit)).map(toSymbolRow);
+  }
+  /** Symbols that call a given name (both bare `foo()` and `x.foo()`). */
+  findCallers(name, opts = {}) {
+    return this.db.prepare(
+      `SELECT r.id, f.path AS file, r.from_symbol, r.name, r.kind, r.start_row, r.start_col
+         FROM refs r JOIN files f ON f.id = r.file_id
+         WHERE r.name = ? AND r.kind IN ('call', 'method')
+         ORDER BY f.path, r.start_row LIMIT ?`
+    ).all(name, clampLimit(opts.limit)).map(toRefRow);
+  }
+  /** All references (calls + imports) to a name. */
+  findReferences(name, opts = {}) {
+    const limit = clampLimit(opts.limit);
+    const rows = opts.kind ? this.db.prepare(
+      `SELECT r.id, f.path AS file, r.from_symbol, r.name, r.kind, r.start_row, r.start_col
+             FROM refs r JOIN files f ON f.id = r.file_id
+             WHERE r.name = ? AND r.kind = ? ORDER BY f.path, r.start_row LIMIT ?`
+    ).all(name, opts.kind, limit) : this.db.prepare(
+      `SELECT r.id, f.path AS file, r.from_symbol, r.name, r.kind, r.start_row, r.start_col
+             FROM refs r JOIN files f ON f.id = r.file_id
+             WHERE r.name = ? ORDER BY f.path, r.start_row LIMIT ?`
+    ).all(name, limit);
+    return rows.map(toRefRow);
+  }
+  /** The symbols defined in a file, in source order. */
+  fileOutline(path) {
+    return this.db.prepare(
+      `SELECT ${SYMBOL_COLUMNS} FROM symbols s JOIN files f ON f.id = s.file_id
+         WHERE f.path = ? ORDER BY s.start_row, s.start_col`
+    ).all(path).map(toSymbolRow);
+  }
+  /** Distinct (callee, callKind) pairs invoked from inside symbols named `from`. */
+  calleesOf(from) {
+    return this.db.prepare(
+      "SELECT DISTINCT name, kind FROM refs WHERE from_symbol = ? AND kind IN ('call','method')"
+    ).all(from);
+  }
+  /** Distinct caller symbol names that invoke `name`. */
+  callersOf(name) {
+    return this.db.prepare(
+      "SELECT DISTINCT from_symbol FROM refs WHERE name = ? AND kind IN ('call','method') AND from_symbol IS NOT NULL"
+    ).all(name).map((r) => r.from_symbol);
+  }
+  /**
+   * Resolve a callee name to project definitions, honouring how it was called:
+   * a bare `foo()` resolves to non-method symbols, an `x.foo()` resolves to
+   * methods. Ambiguous names (more than `ambiguityCap` definitions — typically
+   * library-ish names like `push`/`map`) are treated as unresolved so they
+   * don't blow up the neighbourhood. Returns `null` when nothing resolves.
+   */
+  resolveCallee(name, callKind, ambiguityCap) {
+    const defs = this.getSymbol(name, { limit: ambiguityCap + 1 }).filter(
+      (d) => callKind === "method" ? d.kind === "method" : d.kind !== "method"
+    );
+    if (defs.length === 0 || defs.length > ambiguityCap) return null;
+    return defs;
+  }
+  /**
+   * A bounded call neighbourhood around `name`: callers and callees expanded
+   * breadth-first up to `depth`. Only edges between *resolvable project
+   * symbols* are followed, so the result is the relevant slice of the codebase
+   * — the payload a coding agent reads instead of grepping the whole repo.
+   */
+  neighborhood(name, opts = {}) {
+    const depth = Math.max(1, Math.min(opts.depth ?? 2, 5));
+    const limit = clampLimit(opts.limit, 200);
+    const maxFanout = opts.maxFanout ?? 25;
+    const ambiguityCap = opts.ambiguityCap ?? 4;
+    const seen = /* @__PURE__ */ new Set([name]);
+    const edges = [];
+    const edgeKeys = /* @__PURE__ */ new Set();
+    let frontier = [name];
+    for (let d = 0; d < depth && frontier.length > 0 && seen.size < limit; d++) {
+      const next = /* @__PURE__ */ new Set();
+      for (const node of frontier) {
+        let fanout = 0;
+        for (const callee of this.calleesOf(node)) {
+          if (fanout >= maxFanout) break;
+          if (!this.resolveCallee(callee.name, callee.kind, ambiguityCap)) continue;
+          fanout++;
+          addEdge(edges, edgeKeys, node, callee.name);
+          if (!seen.has(callee.name) && seen.size < limit) {
+            seen.add(callee.name);
+            next.add(callee.name);
+          }
+        }
+        let callerFanout = 0;
+        for (const caller of this.callersOf(node)) {
+          if (callerFanout >= maxFanout) break;
+          callerFanout++;
+          addEdge(edges, edgeKeys, caller, node);
+          if (!seen.has(caller) && seen.size < limit) {
+            seen.add(caller);
+            next.add(caller);
+          }
+        }
+      }
+      frontier = [...next];
+    }
+    const nodes = [];
+    const unresolved = [];
+    for (const n of seen) {
+      const defs = this.getSymbol(n, { limit: 5 });
+      if (defs.length > 0) nodes.push(...defs);
+      else unresolved.push(n);
+    }
+    return { root: name, nodes, edges, unresolved };
+  }
+  /** Aggregate counts for the whole graph. */
+  stats() {
+    const files = this.count("SELECT COUNT(*) AS n FROM files");
+    const symbols = this.count("SELECT COUNT(*) AS n FROM symbols");
+    const refs = this.count("SELECT COUNT(*) AS n FROM refs");
+    const byKind = {};
+    for (const r of this.db.prepare(
+      "SELECT kind, COUNT(*) AS n FROM symbols GROUP BY kind"
+    ).all()) {
+      byKind[r.kind] = r.n;
+    }
+    const byLang = {};
+    for (const r of this.db.prepare(
+      "SELECT lang, COUNT(*) AS n FROM files GROUP BY lang"
+    ).all()) {
+      byLang[r.lang] = r.n;
+    }
+    return { files, symbols, refs, byKind, byLang };
+  }
+  close() {
+    this.db.close();
+  }
+  count(sql) {
+    return this.db.prepare(sql).get()?.n ?? 0;
+  }
+  transaction(fn) {
+    this.db.transaction(fn)();
+  }
+  transactionResult(fn) {
+    return this.db.transaction(fn)();
+  }
+};
+function addEdge(edges, keys, from, to) {
+  const key = `${from}\0${to}`;
+  if (!keys.has(key)) {
+    keys.add(key);
+    edges.push({ from, to });
+  }
+}
+function clampLimit(limit, max = 500) {
+  if (!limit || limit <= 0) return 50;
+  return Math.min(limit, max);
+}
+function escapeLike(s) {
+  return s.replace(/[\\%_]/g, (c2) => `\\${c2}`);
+}
+function toSymbolRow(r) {
+  return {
+    id: r.id,
+    file: r.file,
+    name: r.name,
+    kind: r.kind,
+    container: r.container,
+    exported: r.exported === 1,
+    signature: r.signature,
+    startRow: r.start_row,
+    startCol: r.start_col,
+    endRow: r.end_row,
+    endCol: r.end_col
+  };
+}
+function toRefRow(r) {
+  return {
+    id: r.id,
+    file: r.file,
+    fromSymbol: r.from_symbol,
+    name: r.name,
+    kind: r.kind,
+    startRow: r.start_row,
+    startCol: r.start_col
+  };
+}
+
+// src/watcher.ts
+import { watch as chokidarWatch } from "chokidar";
+var IGNORED = /(?:^|[\\/])(?:node_modules|\.git|dist|build|coverage|\.codescope|target|__pycache__)(?:[\\/]|$)/;
+function watch(indexer, events = {}, opts = {}) {
+  const watcher = chokidarWatch(indexer.root, {
+    ignoreInitial: true,
+    ignored: (path) => IGNORED.test(path),
+    usePolling: opts.usePolling,
+    interval: opts.interval
+  });
+  const onUpsert = (abs) => {
+    if (!languageForPath(abs)) return;
+    indexer.indexFile(abs).then((outcome) => {
+      if (outcome === "indexed") events.onChange?.(indexer.rel(abs), "indexed");
+    }).catch((err) => events.onError?.(err));
+  };
+  watcher.on("add", onUpsert).on("change", onUpsert).on("unlink", (abs) => {
+    if (indexer.removeFile(abs)) events.onChange?.(indexer.rel(abs), "removed");
+  }).on("error", (err) => events.onError?.(err)).on("ready", () => events.onReady?.());
+  return {
+    close: () => watcher.close()
+  };
+}
+
+// src/cli.ts
+var HELP = `codescope ${VERSION} \u2014 local-first codebase knowledge-graph MCP server
+
+Usage:
+  codescope <command> [path] [options]
+
+Commands:
+  mcp [path]              Index, watch for changes, and serve the graph over MCP (stdio).
+                          This is what you wire into Claude Code / Cursor / Codex.
+  index [path]            Build (or refresh) the on-disk graph and print stats.
+  watch [path]            Index, then keep the graph fresh as files change (logs updates).
+  stats [path]            Show counts for the indexed graph.
+  search <query> [path]   Fuzzy-search symbol names.
+  get <name> [path]       Look up a definition by exact name.
+  callers <name> [path]   List callers of a function/method.
+  neighborhood <name>     Show the call neighbourhood around a symbol.
+
+Options:
+  --path <dir>            Repository root (default: current directory or the positional path).
+  --db <file>            SQLite graph location (default: <root>/.codescope/graph.db).
+  --memory               Use an in-memory graph (not persisted).
+  --kind <kind>          Restrict search to: function|method|class|interface|type|enum|variable.
+  --limit <n>            Max results (default 50).
+  --depth <n>            neighbourhood hops (default 2).
+  -h, --help             Show this help.
+  -v, --version          Show version.
+
+Examples:
+  codescope index .
+  codescope search useState
+  codescope neighborhood handleRequest --depth 3
+  codescope mcp .            # add this command to your agent's MCP config
+`;
+function parseArgs(argv) {
+  const flags = { positional: [], memory: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--memory":
+        flags.memory = true;
+        break;
+      case "--path":
+        flags.path = argv[++i];
+        break;
+      case "--db":
+        flags.db = argv[++i];
+        break;
+      case "--kind":
+        flags.kind = argv[++i];
+        break;
+      case "--limit":
+        flags.limit = Number(argv[++i]);
+        break;
+      case "--depth":
+        flags.depth = Number(argv[++i]);
+        break;
+      default:
+        flags.positional.push(arg);
+    }
+  }
+  return flags;
+}
+function rootDir(flags, positionalRootIndex = 0) {
+  return resolve2(flags.path ?? flags.positional[positionalRootIndex] ?? ".");
+}
+function openStore(root, flags) {
+  if (flags.memory) return new GraphStore(":memory:");
+  const dir = resolve2(root, ".codescope");
+  mkdirSync(dir, { recursive: true });
+  return new GraphStore(flags.db ?? resolve2(dir, "graph.db"));
+}
+async function ensureIndexed(indexer, store) {
+  if (store.stats().files === 0) {
+    await indexer.indexAll();
+  }
+}
+async function cmdIndex(root, flags) {
+  const store = openStore(root, flags);
+  const indexer = new Indexer(store, root);
+  process.stderr.write(pc.dim(`Indexing ${root} \u2026
+`));
+  const result = await indexer.indexAll();
+  const { files, symbols, refs } = store.stats();
+  process.stdout.write(
+    `${pc.green("\u2713")} indexed ${pc.bold(String(result.indexed))} files (${result.skipped} unchanged, ${result.removed} removed) in ${result.durationMs}ms
+  ${files} files \xB7 ${symbols} symbols \xB7 ${refs} refs
+`
+  );
+  if (result.errors.length > 0) {
+    process.stderr.write(pc.yellow(`  ${result.errors.length} file(s) failed to parse
+`));
+  }
+  store.close();
+}
+async function cmdStats(root, flags) {
+  const store = openStore(root, flags);
+  const indexer = new Indexer(store, root);
+  await ensureIndexed(indexer, store);
+  process.stdout.write(`${formatStats(store.stats())}
+`);
+  store.close();
+}
+async function cmdQuery(command, root, flags) {
+  const term = flags.positional[0];
+  if (!term) fail(`'${command}' needs an argument. See --help.`);
+  const store = openStore(root, flags);
+  const indexer = new Indexer(store, root);
+  await ensureIndexed(indexer, store);
+  let out;
+  switch (command) {
+    case "search":
+      out = formatSymbols(
+        store.searchSymbols(term, { kind: flags.kind, limit: flags.limit })
+      );
+      break;
+    case "get":
+      out = formatSymbols(store.getSymbol(term, { limit: flags.limit }));
+      break;
+    case "callers":
+      out = formatRefs(store.findCallers(term, { limit: flags.limit }));
+      break;
+    case "neighborhood":
+      out = formatNeighborhood(store.neighborhood(term, { depth: flags.depth, limit: flags.limit }));
+      break;
+    default:
+      out = "";
+  }
+  process.stdout.write(`${out}
+`);
+  store.close();
+}
+async function cmdWatch(root, flags) {
+  const store = openStore(root, flags);
+  const indexer = new Indexer(store, root);
+  process.stderr.write(pc.dim(`Indexing ${root} \u2026
+`));
+  await indexer.indexAll();
+  process.stderr.write(`${pc.green("\u2713")} watching for changes (ctrl-c to stop)
+`);
+  watch(indexer, {
+    onChange: (rel, action) => process.stderr.write(`${action === "indexed" ? pc.cyan("\u21BB") : pc.red("\u2717")} ${rel}
+`),
+    onError: (err) => process.stderr.write(pc.yellow(`watch error: ${String(err)}
+`))
+  });
+  await new Promise(() => {
+  });
+}
+async function cmdMcp(root, flags) {
+  const store = openStore(root, flags);
+  const indexer = new Indexer(store, root);
+  process.stderr.write(pc.dim(`codescope: indexing ${root} \u2026
+`));
+  const result = await indexer.indexAll();
+  process.stderr.write(
+    pc.dim(`codescope: ${result.indexed} files indexed, watching for changes
+`)
+  );
+  watch(indexer, {
+    onChange: (rel, action) => process.stderr.write(pc.dim(`codescope: ${action} ${rel}
+`)),
+    onError: (err) => process.stderr.write(pc.yellow(`codescope: watch error ${String(err)}
+`))
+  });
+  await runStdioServer(store);
+}
+function fail(message) {
+  process.stderr.write(`${pc.red("error:")} ${message}
+`);
+  process.exit(1);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv[0] === "-h" || argv[0] === "--help" || argv[0] === "help") {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (argv[0] === "-v" || argv[0] === "--version" || argv[0] === "version") {
+    process.stdout.write(`${VERSION}
+`);
+    return;
+  }
+  const command = argv[0];
+  const flags = parseArgs(argv.slice(1));
+  switch (command) {
+    case "index":
+      return cmdIndex(rootDir(flags), flags);
+    case "stats":
+      return cmdStats(rootDir(flags), flags);
+    case "search":
+    case "get":
+    case "callers":
+    case "neighborhood":
+      return cmdQuery(command, resolve2(flags.path ?? flags.positional[1] ?? "."), flags);
+    case "watch":
+      return cmdWatch(rootDir(flags), flags);
+    case "mcp":
+      return cmdMcp(rootDir(flags), flags);
+    default:
+      fail(`unknown command '${command}'. See --help.`);
+  }
+}
+main().catch((err) => fail(err instanceof Error ? err.message : String(err)));
+//# sourceMappingURL=cli.js.map