@leanlabsinnov/codegraph 0.1.0

package/dist/chunk-O4ZO6CP5.js

@@ -0,0 +1,2446 @@
+import {
+  createLlmRouter,
+  namespaceLabel
+} from "./chunk-B2TIVKUB.js";
+import {
+  GraphDb,
+  defaultDbPath
+} from "./chunk-F5QKPRNW.js";
+import {
+  DEFAULT_CONFIG,
+  LLM_PRESETS,
+  makeFileId,
+  makeNodeId
+} from "./chunk-XGPZDCQ4.js";
+
+// src/config-store.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+var CONFIG_DIR = path.join(os.homedir(), ".codegraph");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function configPath() {
+  return CONFIG_FILE;
+}
+async function loadConfig() {
+  try {
+    const raw = await readFile(CONFIG_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    return mergeConfig(DEFAULT_CONFIG, parsed);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return DEFAULT_CONFIG;
+    }
+    throw err;
+  }
+}
+async function saveConfig(config) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function mergeConfig(base, override) {
+  return {
+    llm: {
+      ...base.llm,
+      ...override.llm ?? {},
+      generation: { ...base.llm.generation, ...override.llm?.generation ?? {} },
+      embeddings: { ...base.llm.embeddings, ...override.llm?.embeddings ?? {} }
+    },
+    server: { ...base.server, ...override.server ?? {} },
+    data: { ...base.data, ...override.data ?? {} }
+  };
+}
+
+// src/ui.ts
+import boxen from "boxen";
+import Table from "cli-table3";
+import kleur from "kleur";
+import ora from "ora";
+var ASCII_LOGO = `   ___          _        ___                 _
+  / __\\___   __| | ___  / _ \\_ __ __ _ _ __ | |__
+ / /  / _ \\ / _\` |/ _ \\/ /_\\/ '__/ _\` | '_ \\| '_ \\
+/ /__| (_) | (_| |  __/ /_\\\\| | | (_| | |_) | | | |
+\\____/\\___/ \\__,_|\\___\\____/|_|  \\__,_| .__/|_| |_|
+                                      |_|`;
+var TAGLINE = "Live, queryable knowledge graph for your codebase.";
+function printBanner() {
+  if (!process.stdout.isTTY) return;
+  const body = `${kleur.cyan(ASCII_LOGO)}
+
+${kleur.dim(TAGLINE)}`;
+  process.stdout.write(
+    `${boxen(body, {
+      padding: { top: 0, bottom: 0, left: 2, right: 2 },
+      margin: { top: 0, bottom: 1, left: 0, right: 0 },
+      borderStyle: "round",
+      borderColor: "cyan",
+      title: kleur.bold("codegraph"),
+      titleAlignment: "left"
+    })}
+`
+  );
+}
+function makeSpinner(text) {
+  return ora({
+    text,
+    color: "cyan",
+    spinner: "dots",
+    isEnabled: process.stdout.isTTY === true
+  });
+}
+var ProgressBar = class {
+  constructor(label, total, width = 28) {
+    this.label = label;
+    this.total = total;
+    this.width = width;
+  }
+  label;
+  total;
+  lastRender = 0;
+  width;
+  update(current) {
+    if (this.total <= 0) return;
+    if (process.stdout.isTTY !== true) {
+      if (current === this.total || current - this.lastRender >= 25) {
+        process.stdout.write(`${kleur.dim(`${this.label}: ${current}/${this.total}`)}
+`);
+        this.lastRender = current;
+      }
+      return;
+    }
+    const ratio = Math.min(1, current / this.total);
+    const filled = Math.round(ratio * this.width);
+    const bar = `${"\u2588".repeat(filled)}${"\u2591".repeat(this.width - filled)}`;
+    const pct = `${(ratio * 100).toFixed(0).padStart(3)}%`;
+    process.stdout.write(
+      `\r${kleur.cyan(this.label.padEnd(10))} ${kleur.cyan(bar)} ${pct}  ${current}/${this.total}`
+    );
+    if (current >= this.total) process.stdout.write("\n");
+  }
+  done() {
+    this.update(this.total);
+  }
+};
+function renderStatusTables(repoId, stats) {
+  const nodeTable = new Table({
+    head: [kleur.bold("Node kind"), kleur.bold("Count")],
+    colAligns: ["left", "right"],
+    style: { head: [], border: ["grey"] }
+  });
+  for (const [kind, count] of Object.entries(stats.nodes)) {
+    nodeTable.push([kind, count]);
+  }
+  const edgeTable = new Table({
+    head: [kleur.bold("Edge kind"), kleur.bold("Count")],
+    colAligns: ["left", "right"],
+    style: { head: [], border: ["grey"] }
+  });
+  for (const [kind, count] of Object.entries(stats.edges)) {
+    edgeTable.push([kind, count]);
+  }
+  const coverage = `${kleur.bold("Embedding coverage:")} ${kleur.cyan(
+    `${(stats.embeddingCoverage * 100).toFixed(1)}%`
+  )}`;
+  return [kleur.bold(`Status for ${repoId}`), "", nodeTable.toString(), edgeTable.toString(), coverage].join("\n");
+}
+function renderError(err, opts = { verbose: false }) {
+  const message = err instanceof Error ? err.message : String(err);
+  const hint = friendlyHint(message);
+  const lines = [kleur.red().bold("\u2717 codegraph hit an error"), "", kleur.red(message)];
+  if (hint) {
+    lines.push("", kleur.yellow("hint: "), kleur.yellow(hint));
+  }
+  if (opts.verbose && err instanceof Error && err.stack) {
+    lines.push("", kleur.dim(err.stack));
+  } else if (err instanceof Error) {
+    lines.push("", kleur.dim("(re-run with --verbose for a full stack trace)"));
+  }
+  return boxen(lines.join("\n"), {
+    padding: 1,
+    borderColor: "red",
+    borderStyle: "round"
+  });
+}
+function friendlyHint(message) {
+  if (/OPENAI_API_KEY/i.test(message) || /api key/i.test(message)) {
+    return "Set OPENAI_API_KEY in your shell (or switch to local-ollama with `codegraph config llm set local-ollama`).";
+  }
+  if (/ANTHROPIC_API_KEY/i.test(message)) {
+    return "Set ANTHROPIC_API_KEY, or switch presets via `codegraph config llm set <preset>`.";
+  }
+  if (/GOOGLE_GENERATIVE_AI_API_KEY/i.test(message)) {
+    return "Set GOOGLE_GENERATIVE_AI_API_KEY, or switch presets via `codegraph config llm set <preset>`.";
+  }
+  if (/ECONNREFUSED/.test(message) && /11434/.test(message)) {
+    return "Ollama isn't running on :11434. Start it with `ollama serve`, or switch to a hosted provider.";
+  }
+  if (/EACCES|permission denied/i.test(message)) {
+    return "Codegraph stores data in ~/.codegraph. Check that the directory is writable.";
+  }
+  if (/database is locked/i.test(message) || /Lock file/i.test(message)) {
+    return "Another `codegraph` process holds the Kuzu DB. Stop it (or remove ~/.codegraph/graph/.lock) before retrying.";
+  }
+  if (/Unknown preset/i.test(message)) {
+    return "Run `codegraph config llm set` with no args for an interactive prompt.";
+  }
+  return null;
+}
+function renderServeBanner(url, tokenHint) {
+  const body = [
+    `${kleur.green("\u2713")} codegraph mcp listening on ${kleur.cyan(url)}`,
+    "",
+    kleur.dim(tokenHint),
+    kleur.dim("Ctrl-C to stop.")
+  ].join("\n");
+  return boxen(body, {
+    padding: { top: 0, bottom: 0, left: 2, right: 2 },
+    margin: { top: 1, bottom: 1, left: 0, right: 0 },
+    borderColor: "green",
+    borderStyle: "round"
+  });
+}
+
+// src/program.ts
+import { Command } from "commander";
+
+// src/commands/config.ts
+import { password, select } from "@inquirer/prompts";
+import kleur2 from "kleur";
+async function runConfigShow() {
+  const config = await loadConfig();
+  console.log(kleur2.dim(`config file: ${configPath()}`));
+  console.log(JSON.stringify(config, null, 2));
+}
+async function runConfigLlmSet(presetArg) {
+  const presetKeys = Object.keys(LLM_PRESETS);
+  let preset = presetArg;
+  if (!preset) {
+    preset = await select({
+      message: "Which LLM preset?",
+      choices: presetKeys.map((id) => ({
+        name: id,
+        value: id,
+        description: describePreset(id)
+      }))
+    });
+  }
+  const lookup = LLM_PRESETS[preset];
+  if (!lookup) {
+    throw new Error(`Unknown preset "${preset}". Available: ${presetKeys.join(", ")}`);
+  }
+  const config = await loadConfig();
+  config.llm = { ...config.llm, ...lookup };
+  await saveConfig(config);
+  console.log(kleur2.green(`\u2713 saved preset "${preset}" to ${configPath()}`));
+  console.log(kleur2.dim(`embedding namespace: ${namespaceLabel(config.llm)}`));
+  if (!presetArg) {
+    await maybePromptForApiKey(preset);
+  }
+}
+async function maybePromptForApiKey(preset) {
+  const envVar = apiKeyEnvVarFor(preset);
+  if (!envVar) return;
+  if (process.env[envVar]) {
+    console.log(kleur2.dim(`\u2713 ${envVar} already set in environment`));
+    return;
+  }
+  const provideNow = await select({
+    message: `${envVar} is not set. Provide it now?`,
+    choices: [
+      { name: "Yes (paste; I'll print the export line)", value: "yes" },
+      { name: "No, I'll set it later", value: "no" }
+    ]
+  });
+  if (provideNow !== "yes") {
+    console.log(
+      kleur2.yellow(`! Set ${envVar} in your shell before running \`codegraph index\``)
+    );
+    return;
+  }
+  const value = await password({ message: `${envVar} value (input hidden)`, mask: "*" });
+  if (!value) return;
+  console.log(kleur2.dim("Add this to your ~/.zshrc or ~/.bashrc:"));
+  console.log(kleur2.cyan(`  export ${envVar}=${value}`));
+}
+function apiKeyEnvVarFor(preset) {
+  if (preset === "byo-openai" || preset === "managed-stub") return "OPENAI_API_KEY";
+  if (preset === "byo-anthropic") return "ANTHROPIC_API_KEY";
+  if (preset === "byo-google") return "GOOGLE_GENERATIVE_AI_API_KEY";
+  return null;
+}
+function describePreset(id) {
+  switch (id) {
+    case "managed-stub":
+      return "Phase-2 placeholder - same as BYO OpenAI";
+    case "byo-openai":
+      return "Your own OpenAI key (gpt-4o-mini + text-embedding-3-small)";
+    case "byo-anthropic":
+      return "Anthropic for gen, OpenAI for embeddings";
+    case "byo-google":
+      return "Gemini for gen + Google embeddings";
+    case "local-ollama":
+      return "Fully local via Ollama (qwen2.5-coder + nomic-embed-text)";
+    default:
+      return "";
+  }
+}
+async function runConfigLlmTest() {
+  const config = await loadConfig();
+  console.log(kleur2.dim("testing llm config:"));
+  console.log(kleur2.dim(`  mode      ${config.llm.mode}`));
+  console.log(
+    kleur2.dim(`  generate  ${config.llm.generation.provider}:${config.llm.generation.model}`)
+  );
+  console.log(
+    kleur2.dim(`  embed     ${config.llm.embeddings.provider}:${config.llm.embeddings.model}`)
+  );
+  const spinner = makeSpinner("Calling provider").start();
+  try {
+    const router = await createLlmRouter({ config: config.llm });
+    const result = await router.selfTest();
+    spinner.succeed("LLM provider reachable");
+    console.log(`  embed dims:        ${result.embedDims}`);
+    console.log(`  embed latency:     ${result.embedLatencyMs}ms`);
+    console.log(`  generate latency:  ${result.generateLatencyMs}ms`);
+    console.log(`  namespace:         ${namespaceLabel(config.llm)}`);
+  } catch (err) {
+    spinner.fail("LLM provider unreachable");
+    throw err;
+  }
+}
+
+// src/commands/doctor.ts
+import { access, constants, mkdir as mkdir2 } from "fs/promises";
+import { dirname } from "path";
+import kleur3 from "kleur";
+async function runDoctorCommand() {
+  const checks = [];
+  checks.push(checkNodeVersion());
+  let config = null;
+  try {
+    config = await loadConfig();
+    checks.push({ name: "config file", status: "ok", detail: configPath() });
+  } catch (err) {
+    checks.push({
+      name: "config file",
+      status: "fail",
+      detail: err instanceof Error ? err.message : String(err)
+    });
+  }
+  const dbPath = config?.data.dbPath ?? defaultDbPath();
+  checks.push(await checkWritable("graph dir", dbPath));
+  if (config) {
+    checks.push(checkApiKey(config.llm.generation.provider));
+    if (config.llm.embeddings.provider !== config.llm.generation.provider) {
+      checks.push(checkApiKey(config.llm.embeddings.provider));
+    }
+  }
+  if (config) {
+    checks.push(await selfTestLlm(config));
+    checks.push(await selfTestKuzu(dbPath, config.llm.embeddings.dimension));
+  }
+  let failed = 0;
+  let warned = 0;
+  for (const c of checks) {
+    const icon = c.status === "ok" ? kleur3.green("\u2713") : c.status === "warn" ? kleur3.yellow("!") : kleur3.red("\u2717");
+    const name = c.name.padEnd(18);
+    const detail = c.status === "ok" ? kleur3.dim(c.detail) : c.detail;
+    console.log(`${icon}  ${name} ${detail}`);
+    if (c.status === "fail") failed++;
+    if (c.status === "warn") warned++;
+  }
+  console.log();
+  if (failed > 0) {
+    console.log(kleur3.red().bold(`${failed} check(s) failed; codegraph won't work as-is.`));
+    process.exitCode = 1;
+    return;
+  }
+  if (warned > 0) {
+    console.log(kleur3.yellow(`${warned} warning(s); core flows work, optional features may not.`));
+    return;
+  }
+  console.log(kleur3.green().bold("All checks passed. You're ready to `codegraph index <repo>`."));
+}
+function checkNodeVersion() {
+  const version = process.versions.node;
+  const major = Number(version.split(".")[0] ?? 0);
+  if (major >= 20) {
+    return { name: "node version", status: "ok", detail: `v${version}` };
+  }
+  return {
+    name: "node version",
+    status: "fail",
+    detail: `v${version} (codegraph requires >= 20)`
+  };
+}
+async function checkWritable(name, path6) {
+  try {
+    await mkdir2(dirname(path6), { recursive: true });
+    try {
+      await access(path6, constants.W_OK);
+    } catch {
+      await access(dirname(path6), constants.W_OK);
+    }
+    return { name, status: "ok", detail: path6 };
+  } catch (err) {
+    return {
+      name,
+      status: "fail",
+      detail: `${path6} (${err instanceof Error ? err.message : String(err)})`
+    };
+  }
+}
+function checkApiKey(provider) {
+  const envVar = providerEnvVar(provider);
+  if (envVar === null) {
+    return { name: `${provider} key`, status: "ok", detail: "(no key needed)" };
+  }
+  if (process.env[envVar]) {
+    return { name: envVar, status: "ok", detail: "set" };
+  }
+  return {
+    name: envVar,
+    status: "fail",
+    detail: `unset (export ${envVar}=... or switch presets)`
+  };
+}
+function providerEnvVar(provider) {
+  if (provider === "openai") return "OPENAI_API_KEY";
+  if (provider === "anthropic") return "ANTHROPIC_API_KEY";
+  if (provider === "google") return "GOOGLE_GENERATIVE_AI_API_KEY";
+  return null;
+}
+async function selfTestLlm(config) {
+  try {
+    const router = await createLlmRouter({ config: config.llm });
+    const result = await router.selfTest();
+    return {
+      name: "llm round-trip",
+      status: "ok",
+      detail: `embed=${result.embedLatencyMs}ms gen=${result.generateLatencyMs}ms`
+    };
+  } catch (err) {
+    return {
+      name: "llm round-trip",
+      status: "fail",
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function selfTestKuzu(dbPath, embeddingDimension) {
+  const db = new GraphDb({ dbPath, embeddingDimension });
+  try {
+    await db.connect();
+    await db.migrate();
+    const result = await db.query("RETURN 1 AS result");
+    await db.close();
+    if (result.data[0]?.result === 1) {
+      return {
+        name: "kuzu round-trip",
+        status: db.hasVectorIndex() ? "ok" : "warn",
+        detail: db.hasVectorIndex() ? "ok (vector index ready)" : "ok (vector extension missing; semantic search disabled)"
+      };
+    }
+    return { name: "kuzu round-trip", status: "fail", detail: "unexpected result" };
+  } catch (err) {
+    await db.close().catch(() => {
+    });
+    return {
+      name: "kuzu round-trip",
+      status: "fail",
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/commands/index.ts
+import path5 from "path";
+
+// ../ingestion/src/parser.ts
+import { readFile as readFile2 } from "fs/promises";
+import { createRequire } from "module";
+import { extname, dirname as dirname2, join } from "path";
+import Parser from "web-tree-sitter";
+var require2 = createRequire(import.meta.url);
+var GRAMMAR_FILE = {
+  typescript: "tree-sitter-typescript.wasm",
+  tsx: "tree-sitter-tsx.wasm",
+  javascript: "tree-sitter-javascript.wasm",
+  jsx: "tree-sitter-javascript.wasm"
+};
+var initPromise = null;
+var languageCache = /* @__PURE__ */ new Map();
+async function ensureInit() {
+  if (!initPromise) initPromise = Parser.init();
+  await initPromise;
+}
+function grammarPath(lang) {
+  let pkgRoot;
+  try {
+    pkgRoot = dirname2(require2.resolve("tree-sitter-wasms/package.json"));
+  } catch {
+    pkgRoot = join(dirname2(require2.resolve("web-tree-sitter")), "..", "tree-sitter-wasms");
+  }
+  return join(pkgRoot, "out", GRAMMAR_FILE[lang]);
+}
+async function loadLanguage(lang) {
+  await ensureInit();
+  const cached = languageCache.get(lang);
+  if (cached) return cached;
+  const buffer = await readFile2(grammarPath(lang));
+  const loaded = await Parser.Language.load(new Uint8Array(buffer));
+  languageCache.set(lang, loaded);
+  return loaded;
+}
+function detectLanguage(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".ts":
+      return "typescript";
+    case ".tsx":
+      return "tsx";
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    case ".jsx":
+      return "jsx";
+    default:
+      return null;
+  }
+}
+async function parseSource(source, language) {
+  const lang = await loadLanguage(language);
+  const parser = new Parser();
+  parser.setLanguage(lang);
+  const tree = parser.parse(source);
+  if (!tree) {
+    throw new Error(`tree-sitter failed to parse ${language} source`);
+  }
+  return {
+    tree,
+    rootNode: tree.rootNode,
+    language,
+    source
+  };
+}
+
+// ../ingestion/src/extractors/extract.ts
+import { createHash } from "crypto";
+import { basename } from "path";
+
+// ../ingestion/src/walker.ts
+function* walk(node) {
+  const stack = [];
+  for (let i = node.namedChildCount - 1; i >= 0; i--) {
+    const child = node.namedChild(i);
+    if (child) stack.push(child);
+  }
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    yield current;
+    for (let i = current.namedChildCount - 1; i >= 0; i--) {
+      const child = current.namedChild(i);
+      if (child) stack.push(child);
+    }
+  }
+}
+function findChildByType(node, type) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child && child.type === type) return child;
+  }
+  return null;
+}
+function findChildrenByType(node, type) {
+  const out = [];
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child && child.type === type) out.push(child);
+  }
+  return out;
+}
+function nodeText(node, source) {
+  return source.slice(node.startIndex, node.endIndex);
+}
+function startLine(node) {
+  return node.startPosition.row + 1;
+}
+function endLine(node) {
+  return node.endPosition.row + 1;
+}
+function leadingCommentFor(node, source) {
+  let cursor = node.previousNamedSibling;
+  const lines = [];
+  while (cursor && /comment/.test(cursor.type)) {
+    lines.unshift(stripCommentMarkers(nodeText(cursor, source)));
+    cursor = cursor.previousNamedSibling;
+  }
+  return lines.join("\n").trim();
+}
+function stripCommentMarkers(text) {
+  return text.replace(/^\/\*+/, "").replace(/\*+\/$/, "").replace(/^\/\//gm, "").replace(/^\s*\*/gm, "").trim();
+}
+function isPascalCase(name) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(name);
+}
+
+// ../ingestion/src/extractors/routes.ts
+var EXPRESS_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "options",
+  "head",
+  "all",
+  "use"
+]);
+var HTTP_VERBS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+function detectRoutes(input) {
+  return [
+    ...detectExpressRoutes(input),
+    ...detectNextAppRouterRoutes(input),
+    ...detectNextPagesApiRoutes(input)
+  ];
+}
+function detectExpressRoutes(input) {
+  const out = [];
+  for (const node of walk(input.rootNode)) {
+    if (node.type !== "call_expression") continue;
+    const callee = node.childForFieldName("function");
+    if (!callee || callee.type !== "member_expression") continue;
+    const obj = callee.childForFieldName("object");
+    const prop = callee.childForFieldName("property");
+    if (!obj || !prop) continue;
+    const method = nodeText(prop, input.source).toLowerCase();
+    if (!EXPRESS_METHODS.has(method)) continue;
+    const args = node.childForFieldName("arguments");
+    if (!args) continue;
+    const firstArg = args.namedChild(0);
+    if (!firstArg || firstArg.type !== "string") continue;
+    const routePath = stripQuotes(nodeText(firstArg, input.source));
+    if (!routePath.startsWith("/")) continue;
+    const line = startLine(node);
+    const name = `${method.toUpperCase()} ${routePath}`;
+    out.push({
+      id: makeNodeId({
+        repoId: input.repoId,
+        kind: "Route",
+        path: input.relativePath,
+        name,
+        line
+      }),
+      kind: "Route",
+      repoId: input.repoId,
+      name,
+      path: input.relativePath,
+      lineStart: line,
+      lineEnd: endLine(node),
+      method: method.toUpperCase(),
+      routePath,
+      framework: "express"
+    });
+  }
+  return out;
+}
+function detectNextAppRouterRoutes(input) {
+  if (!/(^|\/)app\/.+\/route\.(ts|tsx|js|jsx|mjs|cjs)$/.test(input.relativePath)) return [];
+  const routePath = appRoutePathFor(input.relativePath);
+  const out = [];
+  for (const node of walk(input.rootNode)) {
+    if (node.type !== "export_statement") continue;
+    const decl = findChildByType(node, "function_declaration") ?? findChildByType(node, "lexical_declaration");
+    if (!decl) continue;
+    const name = extractTopLevelName(decl, input.source);
+    if (!name || !HTTP_VERBS.has(name)) continue;
+    const line = startLine(node);
+    out.push({
+      id: makeNodeId({
+        repoId: input.repoId,
+        kind: "Route",
+        path: input.relativePath,
+        name: `${name} ${routePath}`,
+        line
+      }),
+      kind: "Route",
+      repoId: input.repoId,
+      name: `${name} ${routePath}`,
+      path: input.relativePath,
+      lineStart: line,
+      lineEnd: endLine(node),
+      method: name,
+      routePath,
+      framework: "next-app"
+    });
+  }
+  return out;
+}
+function detectNextPagesApiRoutes(input) {
+  if (!/(^|\/)pages\/api\//.test(input.relativePath)) return [];
+  const routePath = pagesApiPathFor(input.relativePath);
+  for (const node of walk(input.rootNode)) {
+    if (node.type !== "export_statement") continue;
+    const text = nodeText(node, input.source);
+    if (!/default/.test(text)) continue;
+    const line = startLine(node);
+    return [
+      {
+        id: makeNodeId({
+          repoId: input.repoId,
+          kind: "Route",
+          path: input.relativePath,
+          name: `ANY ${routePath}`,
+          line
+        }),
+        kind: "Route",
+        repoId: input.repoId,
+        name: `ANY ${routePath}`,
+        path: input.relativePath,
+        lineStart: line,
+        lineEnd: endLine(node),
+        method: "ANY",
+        routePath,
+        framework: "next-pages"
+      }
+    ];
+  }
+  return [];
+}
+function stripQuotes(s) {
+  return s.replace(/^["'`]/, "").replace(/["'`]$/, "");
+}
+function extractTopLevelName(decl, source) {
+  if (decl.type === "function_declaration") {
+    const name = decl.childForFieldName("name");
+    return name ? nodeText(name, source) : null;
+  }
+  if (decl.type === "lexical_declaration") {
+    const declarator = findChildByType(decl, "variable_declarator");
+    if (!declarator) return null;
+    const name = declarator.childForFieldName("name");
+    return name ? nodeText(name, source) : null;
+  }
+  return null;
+}
+function appRoutePathFor(relativePath) {
+  const idx = relativePath.indexOf("app/");
+  const tail = idx >= 0 ? relativePath.slice(idx + "app/".length) : relativePath;
+  const segments = tail.replace(/\/route\.[^/]+$/, "").split("/").filter((seg) => seg.length > 0 && !/^\(.*\)$/.test(seg)).map((seg) => seg.replace(/^\[\.\.\.(.+)\]$/, ":$1*").replace(/^\[(.+)\]$/, ":$1"));
+  return `/${segments.join("/")}` || "/";
+}
+function pagesApiPathFor(relativePath) {
+  const idx = relativePath.indexOf("pages/api/");
+  const tail = idx >= 0 ? relativePath.slice(idx + "pages/api/".length) : relativePath;
+  const base = tail.replace(/\.[^/.]+$/, "");
+  const segments = base.split("/").filter((seg) => seg.length > 0).map(
+    (seg) => seg.replace(/^\[\.\.\.(.+)\]$/, ":$1*").replace(/^\[(.+)\]$/, ":$1").replace(/^index$/, "")
+  ).filter((seg) => seg.length > 0);
+  return `/api/${segments.join("/")}`.replace(/\/+$/, "") || "/api";
+}
+
+// ../ingestion/src/extractors/extract.ts
+async function extractFile(input) {
+  const parsed = await parseSource(input.source, input.language);
+  const fileId = makeFileId({ repoId: input.repoId, path: input.relativePath });
+  const file = {
+    id: fileId,
+    kind: "File",
+    repoId: input.repoId,
+    name: basename(input.relativePath),
+    path: input.relativePath,
+    lineStart: 1,
+    lineEnd: Math.max(1, parsed.rootNode.endPosition.row + 1),
+    language: input.language,
+    sizeBytes: Buffer.byteLength(input.source, "utf8"),
+    contentHash: sha1(input.source)
+  };
+  const nodes = [];
+  const edges = [];
+  const localSymbols = /* @__PURE__ */ new Map();
+  for (const node of walk(parsed.rootNode)) {
+    const symbol = extractSymbol(node, input, parsed.source);
+    if (!symbol) continue;
+    nodes.push(symbol.node);
+    localSymbols.set(symbol.node.name, symbol.node.id);
+    edges.push({ kind: "DEFINES", fromId: fileId, toId: symbol.node.id });
+    if (symbol.node.isExported) {
+      edges.push({ kind: "EXPORTS", fromId: fileId, toId: symbol.node.id });
+    }
+    if (symbol.parentClass) {
+      edges.push({
+        kind: "INHERITS",
+        fromId: symbol.node.id,
+        toId: "",
+        unresolvedTargetName: symbol.parentClass
+      });
+    }
+  }
+  for (const node of walk(parsed.rootNode)) {
+    if (node.type === "import_statement") {
+      const src = findChildByType(node, "string");
+      if (!src) continue;
+      const raw = nodeText(src, parsed.source);
+      const target = raw.slice(1, -1);
+      edges.push({
+        kind: "IMPORTS",
+        fromId: fileId,
+        toId: "",
+        line: startLine(node),
+        fromPath: input.relativePath,
+        toPath: target,
+        unresolvedTargetName: target
+      });
+    }
+  }
+  for (const node of walk(parsed.rootNode)) {
+    if (node.type !== "call_expression") continue;
+    const callee = node.childForFieldName("function");
+    if (!callee) continue;
+    const calleeName = extractCalleeName(callee, parsed.source);
+    if (!calleeName) continue;
+    const enclosing = findEnclosingSymbolId(node, input, parsed.source, localSymbols);
+    if (!enclosing) continue;
+    edges.push({
+      kind: "CALLS",
+      fromId: enclosing,
+      toId: "",
+      line: startLine(node),
+      unresolvedTargetName: calleeName
+    });
+  }
+  if (input.language === "tsx" || input.language === "jsx") {
+    for (const node of walk(parsed.rootNode)) {
+      if (node.type !== "jsx_opening_element" && node.type !== "jsx_self_closing_element") continue;
+      const ident = node.childForFieldName("name") ?? findChildByType(node, "identifier");
+      if (!ident) continue;
+      const tag = nodeText(ident, parsed.source);
+      if (!isPascalCase(tag)) continue;
+      const enclosing = findEnclosingSymbolId(node, input, parsed.source, localSymbols);
+      if (!enclosing) continue;
+      edges.push({
+        kind: "RENDERS",
+        fromId: enclosing,
+        toId: "",
+        line: startLine(node),
+        unresolvedTargetName: tag
+      });
+    }
+  }
+  const routes = detectRoutes({
+    repoId: input.repoId,
+    relativePath: input.relativePath,
+    absolutePath: input.absolutePath,
+    fileId,
+    rootNode: parsed.rootNode,
+    source: parsed.source,
+    language: input.language
+  });
+  for (const route of routes) {
+    nodes.push(route);
+    edges.push({ kind: "DEFINES", fromId: fileId, toId: route.id });
+  }
+  return { file, nodes, edges };
+}
+function extractSymbol(node, input, source) {
+  switch (node.type) {
+    case "function_declaration":
+    case "generator_function_declaration":
+      return functionFromDeclaration(node, input, source);
+    case "class_declaration":
+      return classFromDeclaration(node, input, source);
+    case "interface_declaration":
+      return interfaceFromDeclaration(node, input, source, "Interface");
+    case "type_alias_declaration":
+      return interfaceFromDeclaration(node, input, source, "Interface");
+    case "lexical_declaration":
+    case "variable_declaration":
+      return variableOrArrowFromDeclaration(node, input, source);
+    default:
+      return null;
+  }
+}
+function functionFromDeclaration(node, input, source) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const name = nodeText(nameNode, source);
+  const line = startLine(node);
+  const id = makeNodeId({
+    repoId: input.repoId,
+    kind: "Function",
+    path: input.relativePath,
+    name,
+    line
+  });
+  return {
+    node: {
+      id,
+      kind: "Function",
+      repoId: input.repoId,
+      name,
+      path: input.relativePath,
+      lineStart: line,
+      lineEnd: endLine(node),
+      signature: extractSignature(node, source),
+      leadingComment: leadingCommentFor(parentForLeadingComment(node), source),
+      isExported: isExported(node),
+      isAsync: hasAsyncModifier(node, source)
+    }
+  };
+}
+function classFromDeclaration(node, input, source) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const name = nodeText(nameNode, source);
+  const line = startLine(node);
+  const isComponent = looksLikeComponentClass(node, name, source);
+  const kind = isComponent ? "Component" : "Class";
+  const id = makeNodeId({
+    repoId: input.repoId,
+    kind,
+    path: input.relativePath,
+    name,
+    line
+  });
+  const parentClass = extractExtendsName(node, source);
+  return {
+    node: {
+      id,
+      kind,
+      repoId: input.repoId,
+      name,
+      path: input.relativePath,
+      lineStart: line,
+      lineEnd: endLine(node),
+      signature: `class ${name}${parentClass ? ` extends ${parentClass}` : ""}`,
+      leadingComment: leadingCommentFor(parentForLeadingComment(node), source),
+      isExported: isExported(node)
+    },
+    ...parentClass !== void 0 ? { parentClass } : {}
+  };
+}
+function interfaceFromDeclaration(node, input, source, kind) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const name = nodeText(nameNode, source);
+  const line = startLine(node);
+  const id = makeNodeId({
+    repoId: input.repoId,
+    kind,
+    path: input.relativePath,
+    name,
+    line
+  });
+  return {
+    node: {
+      id,
+      kind,
+      repoId: input.repoId,
+      name,
+      path: input.relativePath,
+      lineStart: line,
+      lineEnd: endLine(node),
+      signature: nodeText(node, source).split("\n")[0]?.slice(0, 200) ?? "",
+      leadingComment: leadingCommentFor(parentForLeadingComment(node), source),
+      isExported: isExported(node)
+    }
+  };
+}
+function variableOrArrowFromDeclaration(node, input, source) {
+  const declarators = findChildrenByType(node, "variable_declarator");
+  if (declarators.length === 0) return null;
+  const decl = declarators[0];
+  if (!decl) return null;
+  const nameNode = decl.childForFieldName("name");
+  const value = decl.childForFieldName("value");
+  if (!nameNode) return null;
+  const name = nodeText(nameNode, source);
+  const line = startLine(decl);
+  const isArrow = value?.type === "arrow_function" || value?.type === "function_expression";
+  if (isArrow) {
+    const isComponent = isPascalCase(name) && containsJsx(value);
+    const kind = isComponent ? "Component" : "Function";
+    const id2 = makeNodeId({
+      repoId: input.repoId,
+      kind,
+      path: input.relativePath,
+      name,
+      line
+    });
+    return {
+      node: {
+        id: id2,
+        kind,
+        repoId: input.repoId,
+        name,
+        path: input.relativePath,
+        lineStart: line,
+        lineEnd: endLine(decl),
+        signature: extractSignature(value, source),
+        leadingComment: leadingCommentFor(node, source),
+        isExported: isExported(node),
+        ...kind === "Function" ? { isArrow: true } : {}
+      }
+    };
+  }
+  const id = makeNodeId({
+    repoId: input.repoId,
+    kind: "Variable",
+    path: input.relativePath,
+    name,
+    line
+  });
+  return {
+    node: {
+      id,
+      kind: "Variable",
+      repoId: input.repoId,
+      name,
+      path: input.relativePath,
+      lineStart: line,
+      lineEnd: endLine(decl),
+      signature: nodeText(decl, source).split("\n")[0]?.slice(0, 200) ?? "",
+      leadingComment: leadingCommentFor(node, source),
+      isExported: isExported(node)
+    }
+  };
+}
+function extractSignature(node, source) {
+  if (!node) return "";
+  const params = node.childForFieldName("parameters");
+  const ret = node.childForFieldName("return_type");
+  const name = node.childForFieldName("name");
+  const head = name ? nodeText(name, source) : "";
+  const ps = params ? nodeText(params, source) : "()";
+  const rs = ret ? ` ${nodeText(ret, source)}` : "";
+  return `${head}${ps}${rs}`.trim().slice(0, 200);
+}
+function extractCalleeName(callee, source) {
+  if (callee.type === "identifier") return nodeText(callee, source);
+  if (callee.type === "member_expression") {
+    const property = callee.childForFieldName("property");
+    if (property) return nodeText(property, source);
+  }
+  return null;
+}
+function extractExtendsName(classNode, source) {
+  const heritage = findChildByType(classNode, "class_heritage");
+  if (!heritage) return void 0;
+  const extendsClause = findChildByType(heritage, "extends_clause");
+  if (!extendsClause) {
+    const ident2 = findChildByType(heritage, "identifier");
+    if (ident2) return nodeText(ident2, source);
+    return void 0;
+  }
+  const ident = findChildByType(extendsClause, "identifier") ?? findChildByType(extendsClause, "member_expression");
+  return ident ? nodeText(ident, source) : void 0;
+}
+function looksLikeComponentClass(classNode, name, source) {
+  if (!isPascalCase(name)) return false;
+  const parent = extractExtendsName(classNode, source) ?? "";
+  return /(?:^|\.)Component$|PureComponent$/.test(parent);
+}
+function containsJsx(node) {
+  if (!node) return false;
+  for (const child of walk(node)) {
+    if (child.type === "jsx_element" || child.type === "jsx_self_closing_element" || child.type === "jsx_fragment") {
+      return true;
+    }
+  }
+  return false;
+}
+function hasAsyncModifier(node, source) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "async" || nodeText(child, source) === "async") return true;
+    if (child.type === "function" || child.type === "class") return false;
+  }
+  return false;
+}
+function isExported(node) {
+  let cursor = node.parent;
+  while (cursor) {
+    if (cursor.type === "export_statement") return true;
+    if (cursor.type === "program") return false;
+    cursor = cursor.parent;
+  }
+  return false;
+}
+function parentForLeadingComment(node) {
+  let cursor = node;
+  while (cursor.parent && cursor.parent.type === "export_statement") {
+    cursor = cursor.parent;
+  }
+  return cursor;
+}
+function findEnclosingSymbolId(node, input, source, localSymbols) {
+  let cursor = node.parent;
+  while (cursor) {
+    if (cursor.type === "function_declaration" || cursor.type === "method_definition" || cursor.type === "class_declaration" || cursor.type === "arrow_function" || cursor.type === "function_expression") {
+      const name = enclosingDeclarationName(cursor, source);
+      if (name) {
+        const id = localSymbols.get(name);
+        if (id) return id;
+      }
+    }
+    cursor = cursor.parent;
+  }
+  return makeFileId({ repoId: input.repoId, path: input.relativePath });
+}
+function enclosingDeclarationName(node, source) {
+  const nameField = node.childForFieldName("name");
+  if (nameField) return nodeText(nameField, source);
+  let cursor = node.parent;
+  while (cursor) {
+    if (cursor.type === "variable_declarator") {
+      const declName = cursor.childForFieldName("name");
+      if (declName) return nodeText(declName, source);
+      return null;
+    }
+    if (cursor.type === "function_declaration" || cursor.type === "class_declaration") return null;
+    cursor = cursor.parent;
+  }
+  return null;
+}
+function sha1(s) {
+  return createHash("sha1").update(s).digest("hex");
+}
+
+// ../ingestion/src/extractors/resolve.ts
+import path2 from "path";
+var EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+function resolveEdges(input) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const n of input.nodes) {
+    if (n.kind === "File") continue;
+    if (!byName.has(n.name)) byName.set(n.name, n.id);
+  }
+  const out = [];
+  let dropped = 0;
+  for (const edge of input.edges) {
+    if (edge.toId) {
+      out.push(edge);
+      continue;
+    }
+    if (!edge.unresolvedTargetName) {
+      dropped++;
+      continue;
+    }
+    if (edge.kind === "IMPORTS") {
+      const resolved = resolveImportPath({
+        repoId: input.repoId,
+        fromPath: edge.fromPath ?? "",
+        spec: edge.unresolvedTargetName,
+        known: input.knownFilePaths
+      });
+      if (!resolved) {
+        dropped++;
+        continue;
+      }
+      const targetId2 = makeFileId({ repoId: input.repoId, path: resolved });
+      const { unresolvedTargetName: _unused2, ...rest2 } = edge;
+      out.push({ ...rest2, toId: targetId2, toPath: resolved });
+      continue;
+    }
+    const targetId = byName.get(edge.unresolvedTargetName);
+    if (!targetId) {
+      dropped++;
+      continue;
+    }
+    const { unresolvedTargetName: _unused, ...rest } = edge;
+    out.push({ ...rest, toId: targetId });
+  }
+  return { resolved: out, dropped };
+}
+function resolveImportPath(input) {
+  const { fromPath, spec, known } = input;
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return null;
+  const baseDir = path2.posix.dirname(toPosix(fromPath));
+  const joined = path2.posix.normalize(path2.posix.join(baseDir, toPosix(spec)));
+  const candidates = [joined];
+  const ext = path2.posix.extname(joined);
+  const stem = ext ? joined.slice(0, -ext.length) : joined;
+  for (const e of EXTENSIONS) candidates.push(`${stem}${e}`);
+  for (const e of EXTENSIONS) candidates.push(`${stem}/index${e}`);
+  for (const c of candidates) {
+    if (known.has(c)) return c;
+  }
+  return null;
+}
+function toPosix(p) {
+  return p.split(path2.sep).join("/");
+}
+
+// ../ingestion/src/orchestrator.ts
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import { cpus } from "os";
+import { join as join2 } from "path";
+import { createHash as createHash2 } from "crypto";
+import ignore2 from "ignore";
+
+// ../ingestion/src/embedder.ts
+function buildEmbeddingInput(node) {
+  const sig = node.signature ?? "";
+  const comment = node.leadingComment ?? "";
+  return `${node.kind} ${node.name}
+${sig}
+${comment}`.trim();
+}
+async function embedNodes(nodes, opts) {
+  const batchSize = opts.batchSize ?? 100;
+  const candidates = nodes.filter((n) => n.kind !== "File");
+  const result = [];
+  const total = Math.ceil(candidates.length / batchSize);
+  const namespace = `${opts.router.config.embeddingNamespace.provider}:${opts.router.config.embeddingNamespace.model}:${opts.router.config.embeddingNamespace.dimension}`;
+  for (let i = 0; i < candidates.length; i += batchSize) {
+    const slice = candidates.slice(i, i + batchSize);
+    const inputs = slice.map(buildEmbeddingInput);
+    const vectors = await opts.router.embed(inputs);
+    for (let j = 0; j < slice.length; j++) {
+      const node = slice[j];
+      const vec = vectors[j];
+      if (!node || !vec) continue;
+      result.push({ id: node.id, embedding: vec, embeddingNamespace: namespace });
+    }
+    opts.onBatch?.({
+      batchIndex: i / batchSize,
+      total,
+      embedded: result.length
+    });
+  }
+  return result;
+}
+
+// ../ingestion/src/repo-walker.ts
+import { readFile as readFile3, readdir, stat } from "fs/promises";
+import path3 from "path";
+import ignore from "ignore";
+var ALWAYS_SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  ".turbo",
+  ".cache",
+  "coverage",
+  ".idea",
+  ".vscode"
+]);
+async function walkRepo(root) {
+  const base = path3.resolve(root);
+  const matcher = ignore();
+  await loadGitignoreInto(matcher, base);
+  const out = [];
+  await walkDir(base, "", matcher, out);
+  return out.sort();
+}
+async function walkDir(absDir, relDir, ig, out) {
+  let entries;
+  try {
+    entries = await readdir(absDir, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const name = entry.name;
+    const rel = relDir ? `${relDir}/${name}` : name;
+    const abs = path3.join(absDir, name);
+    if (entry.isDirectory()) {
+      if (ALWAYS_SKIP_DIRS.has(name)) continue;
+      if (ig.ignores(`${rel}/`)) continue;
+      await walkDir(abs, rel, ig, out);
+    } else if (entry.isFile()) {
+      if (ig.ignores(rel)) continue;
+      const s = await safeStat(abs);
+      if (s && s.size > 2e6) continue;
+      out.push(rel);
+    }
+  }
+}
+async function loadGitignoreInto(ig, absDir) {
+  const file = path3.join(absDir, ".gitignore");
+  try {
+    const text = await readFile3(file, "utf8");
+    ig.add(text);
+  } catch {
+  }
+}
+async function safeStat(p) {
+  try {
+    return await stat(p);
+  } catch {
+    return null;
+  }
+}
+
+// ../ingestion/src/orchestrator.ts
+async function indexRepo(opts) {
+  const start = Date.now();
+  const parallelism = Math.max(1, opts.parallelism ?? cpus().length);
+  const files = await walkRepo(opts.repoPath);
+  opts.onProgress?.({ type: "walk", files: files.length });
+  const parsable = files.map((rel) => ({ rel, language: detectLanguage(rel) })).filter(
+    (f) => f.language !== null
+  );
+  const knownFilePaths = new Set(parsable.map((f) => f.rel));
+  const allNodes = [];
+  const allEdges = [];
+  let parsedCount = 0;
+  let failed = 0;
+  await runWithConcurrency(parsable, parallelism, async (entry) => {
+    const abs = join2(opts.repoPath, entry.rel);
+    try {
+      const source = await readFile4(abs, "utf8");
+      const result = await extractFile({
+        repoId: opts.repoId,
+        relativePath: entry.rel,
+        absolutePath: abs,
+        language: entry.language,
+        source
+      });
+      allNodes.push(result.file, ...result.nodes);
+      allEdges.push(...result.edges);
+    } catch (_err) {
+      failed++;
+    } finally {
+      parsedCount++;
+      opts.onProgress?.({ type: "parse", parsed: parsedCount, total: parsable.length });
+    }
+  });
+  const { resolved, dropped } = resolveEdges({
+    repoId: opts.repoId,
+    nodes: allNodes,
+    edges: allEdges,
+    knownFilePaths
+  });
+  await opts.graphDb.deleteByRepo(opts.repoId);
+  await opts.graphDb.upsertNodes(allNodes);
+  await opts.graphDb.upsertEdges(resolved);
+  opts.onProgress?.({ type: "upsert", nodes: allNodes.length, edges: resolved.length });
+  let embeddingCount = 0;
+  if (!opts.skipEmbeddings && opts.router) {
+    const embedded = await embedNodes(allNodes, {
+      router: opts.router,
+      onBatch: ({ embedded: embedded2, total }) => opts.onProgress?.({ type: "embed", embedded: embedded2, total })
+    });
+    await persistEmbeddings(opts.graphDb, embedded);
+    embeddingCount = embedded.length;
+  }
+  return {
+    durationMs: Date.now() - start,
+    parsedFiles: parsedCount - failed,
+    failedFiles: failed,
+    nodes: allNodes.length,
+    edges: resolved.length,
+    embeddings: embeddingCount,
+    droppedEdges: dropped
+  };
+}
+async function persistEmbeddings(graphDb, embedded) {
+  if (embedded.length === 0) return;
+  const BATCH = 100;
+  for (let i = 0; i < embedded.length; i += BATCH) {
+    const batch = embedded.slice(i, i + BATCH);
+    await graphDb.query(
+      `
+        UNWIND $batch AS e
+        MATCH (n:Symbol { id: e.id })
+        SET n.embedding = e.embedding,
+            n.embeddingNamespace = e.embeddingNamespace
+      `,
+      { batch }
+    );
+  }
+}
+async function runWithConcurrency(items, concurrency, fn) {
+  let cursor = 0;
+  const runners = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (cursor < items.length) {
+      const i = cursor++;
+      const item = items[i];
+      if (item === void 0) continue;
+      await fn(item);
+    }
+  });
+  await Promise.all(runners);
+}
+
+// src/commands/index.ts
+import kleur4 from "kleur";
+
+// src/repo-id.ts
+import { createHash as createHash3 } from "crypto";
+import path4 from "path";
+function repoIdFromPath(absPath) {
+  const base = path4.basename(path4.resolve(absPath));
+  const sha = createHash3("sha1").update(path4.resolve(absPath)).digest("hex").slice(0, 8);
+  const safe = base.replace(/[^A-Za-z0-9_-]/g, "_");
+  return `${safe}-${sha}`;
+}
+
+// src/commands/index.ts
+async function runIndexCommand(opts) {
+  const config = await loadConfig();
+  const absolutePath = path5.resolve(opts.repoPath);
+  const repoId = repoIdFromPath(absolutePath);
+  const dbPath = config.data.dbPath ?? defaultDbPath();
+  console.log(kleur4.dim(`repo:    ${absolutePath}`));
+  console.log(kleur4.dim(`id:      ${repoId}`));
+  console.log(kleur4.dim(`graph:   ${dbPath}`));
+  console.log(
+    kleur4.dim(
+      `llm:     ${config.llm.mode} / gen=${config.llm.generation.provider}:${config.llm.generation.model} / embed=${config.llm.embeddings.provider}:${config.llm.embeddings.model}`
+    )
+  );
+  console.log();
+  const graphDb = new GraphDb({
+    dbPath,
+    embeddingDimension: config.llm.embeddings.dimension
+  });
+  const connectSpinner = makeSpinner("Opening graph").start();
+  try {
+    await graphDb.connect();
+    await graphDb.migrate();
+    connectSpinner.succeed(`Graph ready ${kleur4.dim(`(${dbPath})`)}`);
+  } catch (err) {
+    connectSpinner.fail("Failed to open graph");
+    throw err;
+  }
+  let router;
+  if (!opts.noEmbed) {
+    const llmSpinner = makeSpinner("Initialising LLM router").start();
+    try {
+      router = await createLlmRouter({ config: config.llm });
+      llmSpinner.succeed("LLM router initialised");
+    } catch (err) {
+      llmSpinner.warn(
+        `LLM router init failed; continuing without embeddings (${err instanceof Error ? err.message : String(err)})`
+      );
+      router = void 0;
+    }
+  }
+  let parseBar = null;
+  let embedBar = null;
+  const result = await indexRepo({
+    repoId,
+    repoPath: absolutePath,
+    graphDb,
+    ...router ? { router } : {},
+    skipEmbeddings: opts.noEmbed === true || router === void 0,
+    onProgress: (event) => {
+      if (event.type === "walk") {
+        console.log(kleur4.dim(`walked   ${event.files} files`));
+      }
+      if (event.type === "parse") {
+        if (!parseBar) parseBar = new ProgressBar("parsing", event.total);
+        parseBar.update(event.parsed);
+      }
+      if (event.type === "upsert") {
+        console.log(
+          kleur4.dim(`upserted ${event.nodes} nodes, ${event.edges} edges`)
+        );
+      }
+      if (event.type === "embed") {
+        if (!embedBar) embedBar = new ProgressBar("embedding", event.total);
+        embedBar.update(event.embedded);
+      }
+    }
+  });
+  parseBar?.done();
+  embedBar?.done();
+  await graphDb.close();
+  console.log();
+  console.log(
+    kleur4.green().bold(
+      `\u2713 Indexed ${result.nodes} nodes, ${result.edges} edges in ${(result.durationMs / 1e3).toFixed(2)}s`
+    )
+  );
+  console.log(
+    kleur4.dim(
+      `  parsed=${result.parsedFiles}  failed=${result.failedFiles}  embeddings=${result.embeddings}  dropped_edges=${result.droppedEdges}`
+    )
+  );
+}
+async function runStatusCommand(opts) {
+  const config = await loadConfig();
+  const absolutePath = path5.resolve(opts.repoPath);
+  const repoId = repoIdFromPath(absolutePath);
+  const graphDb = new GraphDb({
+    dbPath: config.data.dbPath ?? defaultDbPath(),
+    embeddingDimension: config.llm.embeddings.dimension
+  });
+  const spinner = makeSpinner("Reading graph").start();
+  try {
+    await graphDb.connect();
+    const stats = await graphDb.stats(repoId);
+    await graphDb.close();
+    spinner.stop();
+    console.log(renderStatusTables(repoId, stats));
+  } catch (err) {
+    spinner.fail("Failed to read graph");
+    throw err;
+  }
+}
+
+// ../mcp-server/dist/index.js
+import { createHash as createHash4 } from "crypto";
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+import { homedir } from "os";
+import { dirname as dirname3, resolve } from "path";
+import { randomUUID } from "crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import express from "express";
+import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
+import { z as z10 } from "zod";
+function buildCacheKey(toolName, args, namespace = "v1") {
+  const serialized = stableStringify(args);
+  const hash = createHash4("sha1").update(serialized).digest("hex");
+  return `codegraph:${namespace}:tool:${toolName}:${hash}`;
+}
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, v) => {
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      const sorted = {};
+      for (const key of Object.keys(v).sort()) {
+        sorted[key] = v[key];
+      }
+      return sorted;
+    }
+    return v;
+  });
+}
+var InMemoryCache = class {
+  store = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    if (entry.expiresAt <= Date.now()) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttlSeconds) {
+    this.store.set(key, { value, expiresAt: Date.now() + ttlSeconds * 1e3 });
+  }
+  async close() {
+    this.store.clear();
+  }
+};
+async function memoizeJson(cache, key, ttlSeconds, compute) {
+  const cached = await cache.get(key);
+  if (cached !== null) {
+    try {
+      return JSON.parse(cached);
+    } catch {
+    }
+  }
+  const value = await compute();
+  await cache.set(key, JSON.stringify(value), ttlSeconds);
+  return value;
+}
+var DEFAULT_TOOL_TTL_SECONDS = 30;
+function jsonResult(payload, extra) {
+  const text = JSON.stringify(payload, null, 2);
+  const base = {
+    content: [{ type: "text", text }],
+    structuredContent: isStructuredContent(payload) ? payload : { result: payload }
+  };
+  return extra?.isError ? { ...base, isError: true } : base;
+}
+function isStructuredContent(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+async function cachedJsonResult(toolName, args, deps, compute) {
+  const key = buildCacheKey(toolName, args);
+  const ttl = deps.cacheTtlSeconds ?? DEFAULT_TOOL_TTL_SECONDS;
+  const value = await memoizeJson(deps.cache, key, ttl, compute);
+  return jsonResult(value);
+}
+var inputSchema = {
+  symbol: z.string().min(1).describe("Symbol name. Use `path` for the file when ambiguous."),
+  path: z.string().optional().describe("Optional file path to disambiguate the symbol."),
+  depth: z.number().int().positive().max(6).default(3),
+  limit: z.number().int().positive().max(500).default(200)
+};
+var affectedByTool = {
+  name: "affected_by",
+  config: {
+    title: "Affected By",
+    description: "Reverse-BFS over CALLS and IMPORTS edges to surface every symbol or file whose behaviour could be affected by changing the given symbol. Depth-limited to keep query bounded.",
+    inputSchema,
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  },
+  handler: async ({ symbol, path: path6, depth, limit }, deps) => cachedJsonResult("affected_by", { symbol, path: path6, depth, limit }, deps, async () => {
+    const where = path6 ? "WHERE target.name = $symbol AND target.path = $path" : "WHERE target.name = $symbol";
+    const rows = await deps.graph.query(
+      `MATCH (target:Symbol) ${where}
+         WITH target
+         MATCH path = (affected:Symbol)-[:CALLS|IMPORTS*1..${depth}]->(target)
+         WITH DISTINCT affected, min(length(path)) AS distance
+         RETURN affected.id AS id, affected.name AS name, affected.kind AS kind,
+                affected.path AS path, distance
+         ORDER BY distance ASC, affected.path ASC LIMIT $limit`,
+      { symbol, path: path6 ?? null, limit }
+    );
+    return { symbol, path: path6 ?? null, depth, count: rows.length, affected: rows };
+  })
+};
+var inputSchema2 = {
+  symbol: z2.string().min(1).describe("Symbol name to compute the blast radius for."),
+  path: z2.string().optional().describe("Optional file path to disambiguate the symbol."),
+  depth: z2.number().int().positive().max(6).default(4),
+  sampleSize: z2.number().int().positive().max(50).default(10)
+};
+var blastRadiusTool = {
+  name: "blast_radius",
+  config: {
+    title: "Blast Radius",
+    description: "Reverse-BFS over CALLS, IMPORTS, and RENDERS edges to count the total number of upstream dependents, plus a small sample to give the agent context.",
+    inputSchema: inputSchema2,
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  },
+  handler: async ({ symbol, path: path6, depth, sampleSize }, deps) => cachedJsonResult("blast_radius", { symbol, path: path6, depth, sampleSize }, deps, async () => {
+    const where = path6 ? "WHERE target.name = $symbol AND target.path = $path" : "WHERE target.name = $symbol";
+    const [stats] = await deps.graph.query(
+      `MATCH (target:Symbol) ${where}
+           WITH target
+           MATCH (dependent:Symbol)-[:CALLS|IMPORTS|RENDERS*1..${depth}]->(target)
+           RETURN count(DISTINCT dependent) AS total`,
+      { symbol, path: path6 ?? null }
+    );
+    const sample = await deps.graph.query(
+      `MATCH (target:Symbol) ${where}
+           WITH target
+           MATCH p = (dependent:Symbol)-[:CALLS|IMPORTS|RENDERS*1..${depth}]->(target)
+           WITH DISTINCT dependent, min(length(p)) AS distance
+           RETURN dependent.id AS id, dependent.name AS name, dependent.kind AS kind,
+                  dependent.path AS path, distance
+           ORDER BY distance ASC, dependent.path ASC LIMIT $sampleSize`,
+      { symbol, path: path6 ?? null, sampleSize }
+    );
+    return {
+      symbol,
+      path: path6 ?? null,
+      depth,
+      totalDependents: stats?.total ?? 0,
+      sample
+    };
+  })
+};
+var inputSchema3 = {
+  name: z3.string().min(1).describe("Exact symbol name to find callers of."),
+  limit: z3.number().int().positive().max(500).default(100)
+};
+var findCallersTool = {
+  name: "find_callers",
+  config: {
+    title: "Find Callers",
+    description: "Return symbols that have a CALLS edge to the named target. Uses Phase-1 heuristic edges (identifier-position match).",
+    inputSchema: inputSchema3,
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  },
+  handler: async ({ name, limit }, deps) => cachedJsonResult("find_callers", { name, limit }, deps, async () => {
+    const rows = await deps.graph.query(
+      `MATCH (caller:Symbol)-[:CALLS]->(callee:Symbol)
+         WHERE callee.name = $name
+         RETURN caller.id AS id, caller.name AS name, caller.kind AS kind,
+                caller.path AS path, caller.lineStart AS line
+         ORDER BY caller.path, caller.lineStart LIMIT $limit`,
+      { name, limit }
+    );
+    return { name, count: rows.length, callers: rows };
+  })
+};
+var inputSchema4 = {
+  fragment: z4.string().min(1).describe("Substring to match against file paths."),
+  limit: z4.number().int().positive().max(200).default(50)
+};
+var findFileTool = {
+  name: "find_file",
+  config: {
+    title: "Find File",
+    description: "Locate files in the indexed repo by a substring of their path.",
+    inputSchema: inputSchema4,
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  },
+  handler: async ({ fragment, limit }, deps) => cachedJsonResult("find_file", { fragment, limit }, deps, async () => {
+    const rows = await deps.graph.query(
+      `MATCH (f:Symbol)
+         WHERE f.kind = 'File' AND lower(f.path) CONTAINS lower($q)
+         RETURN f.id AS id, f.path AS path, f.name AS name
+         ORDER BY f.path LIMIT $limit`,
+      { q: fragment, limit }
+    );
+    return { fragment, count: rows.length, matches: rows };
+  })
+};
+var inputSchema5 = {
+  name: z5.string().min(1).describe("Component name (PascalCase)."),
+  depth: z5.number().int().positive().max(8).default(4)
+};
+var getComponentTreeTool = {
+  name: "get_component_tree",
+  config: {
+    title: "Get Component Tree",
+    description: "Recursively walk RENDERS edges from the named component, returning the rendered descendants up to the requested depth.",
+    inputSchema: inputSchema5,
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  },
+  handler: async ({ name, depth }, deps) => cachedJsonResult("get_component_tree", { name, depth }, deps, async () => {
+    const rows = await deps.graph.query(
+      `MATCH (root:Symbol {kind: 'Component', name: $name})
+         OPTIONAL MATCH path = (root)-[:RENDERS*1..${depth}]->(child:Symbol)
+         WHERE child.kind = 'Component'
+         WITH root, collect(DISTINCT { name: child.name, id: child.id, path: child.path, depth: length(path) }) AS children
+         RETURN root.id AS rootId, root.name AS rootName, root.path AS rootPath, children`,
+      { name }
+    );
+    return { name, depth, tree: rows[0] ?? null };
+  })
+};
+var inputSchema6 = {
+  path: z6.string().min(1).describe("Repo-relative file path."),
+  depth: z6.number().int().positive().max(8).default(4),
+  limit: z6.number().int().positive().max(500).default(200)
+};
+var getDependenciesTool = {
+  name: "get_dependencies",
+  config: {
+    title: "Get Dependencies",
+    description: "Forward-BFS over IMPORTS edges, returning every file transitively imported by the given path, with depth.",
+    inputSchema: inputSchema6,
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  },
+  handler: async ({ path: path6, depth, limit }, deps) => cachedJsonResult("get_dependencies", { path: path6, depth, limit }, deps, async () => {
+    const rows = await deps.graph.query(
+      `MATCH (root:Symbol)
+         WHERE root.kind = 'File' AND root.path = $path
+         OPTIONAL MATCH p = (root)-[:IMPORTS*1..${depth}]->(dep:Symbol)
+         WHERE dep.kind = 'File'
+         WITH DISTINCT dep, min(length(p)) AS distance
+         WHERE dep IS NOT NULL
+         RETURN dep.id AS id, dep.path AS path, distance
+         ORDER BY distance ASC, dep.path ASC LIMIT $limit`,
+      { path: path6, limit }
+    );
+    return { path: path6, depth, count: rows.length, dependencies: rows };
+  })
+};
+var inputSchema7 = {
+  path: z7.string().min(1).describe("Repo-relative file path."),
+  symbolLimit: z7.number().int().positive().max(500).default(100)
+};
+var getFileContextTool = {
+  name: "get_file_context",
+  config: {
+    title: "Get File Context",
+    description: "Return the file's defined symbols, imported files, exported symbols, and the files that import it.",
+    inputSchema: inputSchema7,
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  },
+  handler: async ({ path: path6, symbolLimit }, deps) => cachedJsonResult("get_file_context", { path: path6, symbolLimit }, deps, async () => {
+    const fileRows = await deps.graph.query(
+      `MATCH (f:Symbol)
+         WHERE f.kind = 'File' AND f.path = $path
+         RETURN f.id AS id, f.path AS path, f.name AS name LIMIT 1`,
+      { path: path6 }
+    );
+    if (fileRows.length === 0) {
+      return { path: path6, found: false };
+    }
+    const [defined, imports, exports, importers] = await Promise.all([
+      deps.graph.query(
+        `MATCH (f:Symbol)-[:DEFINES]->(s:Symbol)
+           WHERE f.kind = 'File' AND f.path = $path
+           RETURN s.id AS id, s.name AS name, s.kind AS kind, s.lineStart AS line, s.signature AS signature
+           ORDER BY s.lineStart LIMIT $limit`,
+        { path: path6, limit: symbolLimit }
+      ),
+      deps.graph.query(
+        `MATCH (f:Symbol)-[:IMPORTS]->(t:Symbol)
+           WHERE f.kind = 'File' AND t.kind = 'File' AND f.path = $path
+           RETURN DISTINCT t.path AS path ORDER BY t.path`,
+        { path: path6 }
+      ),
+      deps.graph.query(
+        `MATCH (f:Symbol)-[:EXPORTS]->(s:Symbol)
+           WHERE f.kind = 'File' AND f.path = $path
+           RETURN s.id AS id, s.name AS name, s.kind AS kind, s.lineStart AS line
+           ORDER BY s.name`,
+        { path: path6 }
+      ),
+      deps.graph.query(
+        `MATCH (other:Symbol)-[:IMPORTS]->(f:Symbol)
+           WHERE other.kind = 'File' AND f.kind = 'File' AND f.path = $path
+           RETURN DISTINCT other.path AS path ORDER BY other.path`,
+        { path: path6 }
+      )
+    ]);
+    return {
+      path: path6,
+      found: true,
+      file: fileRows[0],
+      definedSymbols: defined,
+      importsFiles: imports,
+      exportedSymbols: exports,
+      importedBy: importers
+    };
+  })
+};
+var ALLOWED_LEADING_CLAUSES = ["MATCH", "OPTIONAL MATCH", "WITH", "UNWIND", "RETURN"];
+var FORBIDDEN_KEYWORDS = [
+  "CREATE",
+  "MERGE",
+  "DELETE",
+  "DETACH DELETE",
+  "SET",
+  "REMOVE",
+  "DROP",
+  "FOREACH",
+  "LOAD CSV"
+];
+function stripComments(src) {
+  return src.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
+}
+function stripStringLiterals(src) {
+  return src.replace(/'(?:\\.|[^'\\])*'/g, "''").replace(/"(?:\\.|[^"\\])*"/g, '""').replace(/`(?:\\.|[^`\\])*`/g, "``");
+}
+function startsWithAllowedClause(upper) {
+  for (const clause of ALLOWED_LEADING_CLAUSES) {
+    if (upper.startsWith(`${clause} `) || upper === clause) {
+      return true;
+    }
+  }
+  return false;
+}
+function findForbiddenKeyword(upper) {
+  for (const kw of FORBIDDEN_KEYWORDS) {
+    const pattern = new RegExp(`\\b${kw.replace(/\s+/g, "\\s+")}\\b`);
+    if (pattern.test(upper)) {
+      return kw;
+    }
+  }
+  return null;
+}
+function validateReadOnlyCypher(input) {
+  if (typeof input !== "string" || input.trim().length === 0) {
+    return { ok: false, reason: "Empty Cypher statement." };
+  }
+  const withoutComments = stripComments(input);
+  const sanitized = stripStringLiterals(withoutComments).trim();
+  const withoutTrailingSemicolon = sanitized.replace(/;\s*$/, "");
+  if (withoutTrailingSemicolon.includes(";")) {
+    return {
+      ok: false,
+      reason: "Multiple statements are not allowed (found `;`).",
+      normalized: sanitized
+    };
+  }
+  const normalized = withoutTrailingSemicolon.trim();
+  const upper = normalized.toUpperCase().replace(/\s+/g, " ").trim();
+  if (!startsWithAllowedClause(upper)) {
+    return {
+      ok: false,
+      reason: `Statement must start with one of: ${ALLOWED_LEADING_CLAUSES.join(", ")}.`,
+      normalized
+    };
+  }
+  const forbidden = findForbiddenKeyword(upper);
+  if (forbidden) {
+    return {
+      ok: false,
+      reason: `Mutating keyword '${forbidden}' is not allowed in nl_query results.`,
+      normalized
+    };
+  }
+  if (/\bCALL\s*\{/.test(upper)) {
+    return {
+      ok: false,
+      reason: "CALL { ... } subqueries are not allowed (they may hide writes).",
+      normalized
+    };
+  }
+  if (/\bCALL\s+[A-Z0-9_.]+\s*\(/.test(upper)) {
+    return {
+      ok: false,
+      reason: "Procedure calls (CALL ns.proc(...)) are not allowed.",
+      normalized
+    };
+  }
+  return { ok: true, normalized };
+}
+var inputSchema8 = {
+  question: z8.string().min(1).describe("Natural-language question about the codebase."),
+  limit: z8.number().int().positive().max(200).default(50).describe("Row cap injected into the generated query as $limit.")
+};
+var SYSTEM_PROMPT = `You translate natural-language questions about a code graph into a single Cypher query.
+
+Schema (Kuzu):
+- Single node table: \`Symbol\`. Distinguish kinds via the \`kind\` STRING column.
+  Valid kinds: File, Function, Class, Interface, Component, Route, Variable.
+- Edge tables (each FROM Symbol TO Symbol): IMPORTS, CALLS, RENDERS, INHERITS, DEFINES, EXPORTS.
+- Useful Symbol columns: id, kind, repoId, name, path, lineStart, lineEnd, signature, leadingComment.
+
+Examples:
+  // All files imported by app.ts:
+  MATCH (a:Symbol)-[:IMPORTS]->(b:Symbol)
+  WHERE a.kind = 'File' AND a.path = 'app.ts' AND b.kind = 'File'
+  RETURN b.path LIMIT $limit
+
+  // What calls useAuth?
+  MATCH (caller:Symbol)-[:CALLS]->(callee:Symbol)
+  WHERE callee.name = 'useAuth'
+  RETURN caller.name, caller.path, caller.kind LIMIT $limit
+
+Constraints you MUST follow:
+- Produce exactly ONE statement.
+- It must be read-only: only MATCH / OPTIONAL MATCH / WITH / UNWIND / RETURN clauses.
+- Do not use CREATE, MERGE, DELETE, SET, REMOVE, DROP, FOREACH, CALL { ... }, or procedure CALLs.
+- Always include a LIMIT (use the $limit parameter that will be passed in).
+- Use \`s.kind = 'File'\` style filters - do NOT use multi-label syntax like \`(s:File)\`.
+- Return useful columns named clearly (id, name, kind, path, line, score, etc.).
+- Output ONLY the Cypher query. No prose, no markdown fences.`;
+var nlQueryTool = {
+  name: "nl_query",
+  config: {
+    title: "Natural-Language Cypher Query",
+    description: "Translate a natural-language question into Cypher via the configured LLM, validate it against a read-only allowlist, then execute it on the graph.",
+    inputSchema: inputSchema8,
+    annotations: { readOnlyHint: true, openWorldHint: true }
+  },
+  handler: async ({ question, limit }, deps) => {
+    const rawCypher = await deps.llm.generate({
+      system: SYSTEM_PROMPT,
+      messages: [{ role: "user", content: question }],
+      temperature: 0,
+      maxTokens: 400
+    });
+    const cypher = stripCodeFence(rawCypher).trim();
+    const guard = validateReadOnlyCypher(cypher);
+    if (!guard.ok) {
+      return jsonResult(
+        {
+          question,
+          accepted: false,
+          rejectedCypher: cypher,
+          reason: guard.reason
+        },
+        { isError: false }
+      );
+    }
+    return cachedJsonResult(
+      "nl_query",
+      { question, limit, cypher: guard.normalized },
+      deps,
+      async () => {
+        try {
+          const rows = await deps.graph.query(guard.normalized ?? cypher, { limit });
+          return {
+            question,
+            accepted: true,
+            cypher: guard.normalized ?? cypher,
+            rowCount: rows.length,
+            rows
+          };
+        } catch (err) {
+          return {
+            question,
+            accepted: true,
+            cypher: guard.normalized ?? cypher,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      }
+    );
+  }
+};
+function stripCodeFence(text) {
+  const fenced = text.match(/```(?:cypher)?\n([\s\S]*?)```/i);
+  if (fenced?.[1]) return fenced[1];
+  return text;
+}
+var inputSchema9 = {
+  description: z9.string().min(1).describe("Natural-language description of the symbol you are looking for."),
+  k: z9.number().int().positive().max(50).default(10).describe("Number of nearest neighbours.")
+};
+var searchSemanticTool = {
+  name: "search_semantic",
+  config: {
+    title: "Semantic Symbol Search",
+    description: "Embed the supplied description via the configured LLM router, then run a vector KNN over indexed symbol embeddings.",
+    inputSchema: inputSchema9,
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  },
+  handler: async ({ description, k }, deps) => {
+    const [embedding] = await deps.llm.embed([description]);
+    if (!embedding) {
+      return jsonResult(
+        { error: "LLM router returned no embedding for the query." },
+        { isError: true }
+      );
+    }
+    const namespace = `${deps.llm.embeddingNamespace.provider}:${deps.llm.embeddingNamespace.model}:${deps.llm.embeddingNamespace.dimension}`;
+    return cachedJsonResult("search_semantic", { description, k, namespace }, deps, async () => {
+      const rows = await deps.graph.query(
+        `CALL QUERY_VECTOR_INDEX('Symbol', 'embedding_idx', $vec, $k)
+           WITH node, distance
+           WHERE node.embeddingNamespace = $ns
+           RETURN node.id AS id, node.name AS name, node.kind AS kind, node.path AS path,
+                  node.lineStart AS line, node.signature AS signature, distance AS score
+           ORDER BY distance ASC`,
+        { vec: embedding, k, ns: namespace }
+      );
+      return { description, k, namespace, count: rows.length, matches: rows };
+    });
+  }
+};
+var inputSchema10 = {
+  query: z10.string().min(1).describe("Substring to match against symbol names (case-insensitive)."),
+  kind: z10.enum(["File", "Function", "Class", "Interface", "Component", "Route", "Variable"]).optional().describe("Optional filter by node kind."),
+  limit: z10.number().int().positive().max(200).default(25)
+};
+var searchSymbolTool = {
+  name: "search_symbol",
+  config: {
+    title: "Search Symbol",
+    description: "Find functions, classes, components, routes, or variables by case-insensitive substring match on the symbol name.",
+    inputSchema: inputSchema10,
+    annotations: { readOnlyHint: true, idempotentHint: true }
+  },
+  handler: async ({ query, kind, limit }, deps) => cachedJsonResult("search_symbol", { query, kind, limit }, deps, async () => {
+    const cypher = kind ? `MATCH (s:Symbol)
+           WHERE s.kind = $kind AND lower(s.name) CONTAINS lower($q)
+           RETURN s.id AS id, s.name AS name, s.kind AS kind, s.path AS path,
+                  s.lineStart AS line, s.signature AS signature
+           ORDER BY s.name LIMIT $limit` : `MATCH (s:Symbol)
+           WHERE s.name IS NOT NULL AND lower(s.name) CONTAINS lower($q)
+           RETURN s.id AS id, s.name AS name, s.kind AS kind, s.path AS path,
+                  s.lineStart AS line, s.signature AS signature
+           ORDER BY s.name LIMIT $limit`;
+    const rows = await deps.graph.query(cypher, { q: query, limit, kind: kind ?? null });
+    return { query, kind: kind ?? null, count: rows.length, matches: rows };
+  })
+};
+var ALL_TOOLS = [
+  searchSymbolTool,
+  findFileTool,
+  searchSemanticTool,
+  getFileContextTool,
+  findCallersTool,
+  getComponentTreeTool,
+  affectedByTool,
+  getDependenciesTool,
+  blastRadiusTool,
+  nlQueryTool
+];
+function registerAllTools(server, deps) {
+  for (const tool of ALL_TOOLS) {
+    server.registerTool(tool.name, tool.config, async (args) => {
+      try {
+        return await tool.handler(args, deps);
+      } catch (err) {
+        deps.logger?.error("tool handler threw", {
+          tool: tool.name,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return jsonResult(
+          {
+            tool: tool.name,
+            error: err instanceof Error ? err.message : String(err)
+          },
+          { isError: true }
+        );
+      }
+    });
+  }
+}
+function createMcpServer(opts) {
+  const info = opts.serverInfo ?? { name: "codegraph", version: "0.0.0" };
+  const server = new McpServer(info, {
+    capabilities: { tools: {}, logging: {} }
+  });
+  registerAllTools(server, opts.deps);
+  return server;
+}
+async function startSseServer(opts) {
+  const { deps, config } = opts;
+  const logger = deps.logger;
+  const app = express();
+  app.use(express.json({ limit: "2mb" }));
+  app.get("/healthz", (_req, res) => {
+    res.status(200).json({ ok: true });
+  });
+  app.use(bearerAuthMiddleware(config.bearerToken, logger));
+  const transports = /* @__PURE__ */ new Map();
+  app.get("/mcp", async (_req, res) => {
+    let transport;
+    try {
+      transport = new SSEServerTransport("/messages", res);
+    } catch (err) {
+      logger?.error("failed to create SSE transport", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      if (!res.headersSent) res.status(500).send("Failed to establish SSE stream");
+      return;
+    }
+    const sessionId = transport.sessionId;
+    transports.set(sessionId, transport);
+    transport.onclose = () => {
+      transports.delete(sessionId);
+      logger?.info("sse session closed", { sessionId });
+    };
+    const server = createMcpServer({ deps, serverInfo: opts.serverInfo });
+    try {
+      await server.connect(transport);
+      logger?.info("sse session opened", { sessionId });
+    } catch (err) {
+      logger?.error("server.connect failed", {
+        sessionId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      transports.delete(sessionId);
+      if (!res.headersSent) res.status(500).send("MCP connect failed");
+    }
+  });
+  app.post("/messages", async (req, res) => {
+    const sessionId = req.query.sessionId;
+    if (!sessionId) {
+      res.status(400).json({ error: "Missing sessionId query parameter" });
+      return;
+    }
+    const transport = transports.get(sessionId);
+    if (!transport) {
+      res.status(404).json({ error: "No active session for sessionId" });
+      return;
+    }
+    try {
+      await transport.handlePostMessage(req, res, req.body);
+    } catch (err) {
+      logger?.error("handlePostMessage failed", {
+        sessionId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      if (!res.headersSent) res.status(500).json({ error: "Failed to handle message" });
+    }
+  });
+  const httpServer = await new Promise((resolve2, reject) => {
+    const srv = app.listen(config.port, config.host, () => resolve2(srv)).on("error", reject);
+  });
+  const address = httpServer.address();
+  if (address === null || typeof address === "string") {
+    throw new Error("HTTP server bound to unexpected address");
+  }
+  logger?.info("codegraph mcp server listening", {
+    host: address.address,
+    port: address.port,
+    tools: 10
+  });
+  const started = {
+    httpServer,
+    address: { host: address.address, port: address.port },
+    async close() {
+      for (const [id, t] of transports) {
+        try {
+          await t.close();
+        } catch {
+        }
+        transports.delete(id);
+      }
+      await new Promise((resolve2, reject) => {
+        httpServer.close((err) => err ? reject(err) : resolve2());
+      });
+      await deps.cache.close?.();
+      await deps.graph.close?.();
+    }
+  };
+  return started;
+}
+function bearerAuthMiddleware(expectedToken, logger) {
+  return (req, res, next) => {
+    const header = req.header("authorization") ?? req.header("Authorization");
+    if (!header || !header.toLowerCase().startsWith("bearer ")) {
+      logger?.warn("auth missing", { path: req.path });
+      res.status(401).json({ error: "Missing bearer token" });
+      return;
+    }
+    const presented = header.slice("bearer ".length).trim();
+    if (!safeEqual(presented, expectedToken)) {
+      logger?.warn("auth rejected", { path: req.path });
+      res.status(403).json({ error: "Invalid bearer token" });
+      return;
+    }
+    next();
+  };
+}
+function safeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+function generateBearerToken() {
+  return randomUUID().replace(/-/g, "");
+}
+var MCP_PORT = 3748;
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_TTL = 30;
+function defaultConfigPath() {
+  return resolve(homedir(), ".codegraph", "config.json");
+}
+async function readCodegraphConfig(path6 = defaultConfigPath()) {
+  try {
+    const raw = await readFile5(path6, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function writeCodegraphConfig(config, path6 = defaultConfigPath()) {
+  await mkdir3(dirname3(path6), { recursive: true });
+  await writeFile2(path6, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function resolveServerConfig(opts) {
+  const path6 = opts.configPath ?? defaultConfigPath();
+  const fileConfig = await readCodegraphConfig(path6);
+  const env = process.env;
+  let bearerToken = opts.overrides?.bearerToken ?? fileConfig.mcpToken ?? fileConfig.server?.bearerToken ?? env.CODEGRAPH_BEARER_TOKEN ?? "";
+  let created = false;
+  if (!bearerToken) {
+    bearerToken = generateBearerToken();
+    created = true;
+    await writeCodegraphConfig(
+      {
+        ...fileConfig,
+        mcpToken: bearerToken,
+        server: { ...fileConfig.server ?? {}, bearerToken }
+      },
+      path6
+    );
+  }
+  const config = {
+    host: opts.overrides?.host ?? fileConfig.server?.host ?? env.CODEGRAPH_HOST ?? DEFAULT_HOST,
+    port: opts.overrides?.port ?? fileConfig.server?.port ?? (env.CODEGRAPH_PORT ? Number(env.CODEGRAPH_PORT) : MCP_PORT),
+    bearerToken,
+    cacheTtlSeconds: opts.overrides?.cacheTtlSeconds ?? fileConfig.server?.cacheTtlSeconds ?? (env.CODEGRAPH_CACHE_TTL ? Number(env.CODEGRAPH_CACHE_TTL) : DEFAULT_TTL)
+  };
+  return { config, configPath: path6, created };
+}
+function resolveDbPath(fileConfig) {
+  return fileConfig.data?.dbPath ?? process.env.CODEGRAPH_DB_PATH ?? void 0;
+}
+function createConsoleLogger(level = "info") {
+  const levels = { info: 10, warn: 20, error: 30 };
+  const min = levels[level];
+  const emit = (lvl, msg, meta) => {
+    if (levels[lvl] < min) return;
+    const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level: lvl, msg, ...meta });
+    process.stderr.write(`${line}
+`);
+  };
+  return {
+    info: (msg, meta) => emit("info", msg, meta),
+    warn: (msg, meta) => emit("warn", msg, meta),
+    error: (msg, meta) => emit("error", msg, meta)
+  };
+}
+async function startMcpServer(portOrOptions) {
+  const options = typeof portOrOptions === "number" ? { port: portOrOptions } : portOrOptions ?? {};
+  const logger = createConsoleLogger();
+  const overrides = {};
+  if (options.port !== void 0) overrides.port = options.port;
+  if (options.host !== void 0) overrides.host = options.host;
+  const { config, configPath: configPath2, created } = await resolveServerConfig({
+    ...options.configPath !== void 0 ? { configPath: options.configPath } : {},
+    overrides
+  });
+  if (created) logger.info("generated new bearer token", { configPath: configPath2 });
+  const fileConfig = await readCodegraphConfig(options.configPath ?? defaultConfigPath());
+  const dbPath = options.dbPath ?? resolveDbPath(fileConfig);
+  const cache = options.deps?.cache ?? new InMemoryCache();
+  const graph = options.deps?.graph ?? await loadGraphClient(dbPath);
+  const llm = options.deps?.llm ?? await loadLlmRouter(options.configPath ?? defaultConfigPath());
+  const deps = {
+    graph,
+    llm,
+    cache,
+    cacheTtlSeconds: config.cacheTtlSeconds,
+    logger
+  };
+  return startSseServer({ deps, config });
+}
+async function loadGraphClient(dbPath) {
+  let mod;
+  try {
+    mod = await import("./src-467W2KXC.js");
+  } catch (err) {
+    throw new Error(
+      `Failed to import @codegraph/graph-db. Run \`pnpm -r build\` first. Underlying error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const GraphDb2 = mod.GraphDb;
+  if (typeof GraphDb2 !== "function") {
+    throw new Error("@codegraph/graph-db has no `GraphDb` export.");
+  }
+  const db = new GraphDb2(dbPath !== void 0 ? { dbPath } : {});
+  await db.connect();
+  await db.migrate();
+  return {
+    async query(cypher, params) {
+      const r = await db.query(cypher, params ?? {});
+      return r.data;
+    },
+    async close() {
+      await db.close();
+    }
+  };
+}
+async function loadLlmRouter(configPath2) {
+  let mod;
+  try {
+    mod = await import("./src-UVET6JHH.js");
+  } catch (err) {
+    throw new Error(
+      `Failed to import @codegraph/llm-router. Run \`pnpm -r build\` first. Underlying error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const createLlmRouter2 = mod.createLlmRouter;
+  if (typeof createLlmRouter2 !== "function") {
+    throw new Error("@codegraph/llm-router has no `createLlmRouter` export.");
+  }
+  const fileConfig = await readCodegraphConfig(configPath2);
+  const router = await createLlmRouter2({
+    config: fileConfig.llm ?? void 0,
+    configPath: configPath2
+  });
+  return adaptLlmRouter(router);
+}
+function adaptLlmRouter(router) {
+  const ns = router.config?.embeddingNamespace ?? (router.config?.embeddings ? {
+    provider: router.config.embeddings.provider,
+    model: router.config.embeddings.model,
+    dimension: router.config.embeddings.dimension
+  } : { provider: "unknown", model: "unknown", dimension: 0 });
+  return {
+    embed: (texts) => router.embed(texts),
+    generate: (opts) => router.generate(opts),
+    embeddingNamespace: ns
+  };
+}
+
+// src/commands/serve.ts
+async function runServeCommand(opts = {}) {
+  const spinner = makeSpinner("Booting MCP server").start();
+  let started;
+  try {
+    started = await startMcpServer({
+      ...opts.port !== void 0 ? { port: opts.port } : {},
+      ...opts.host !== void 0 ? { host: opts.host } : {},
+      ...opts.dbPath !== void 0 ? { dbPath: opts.dbPath } : {}
+    });
+    spinner.stop();
+  } catch (err) {
+    spinner.fail("Server failed to start");
+    throw err;
+  }
+  const url = `http://${started.address.host}:${started.address.port}/mcp`;
+  const tokenHint = "bearer token at ~/.codegraph/config.json (codegraph config show to view)";
+  process.stdout.write(`${renderServeBanner(url, tokenHint)}
+`);
+  const shutdown = async (signal) => {
+    process.stderr.write(`
+shutting down (${signal})...
+`);
+    try {
+      await started.close();
+    } catch (err) {
+      process.stderr.write(
+        `shutdown failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+
+// src/program.ts
+function buildProgram() {
+  const program = new Command();
+  program.name("codegraph").description("Live, queryable knowledge graph for your codebase").version("0.1.0").option("--verbose", "Print full stack traces on error").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.verbose) process.env.CODEGRAPH_VERBOSE = "1";
+  });
+  program.on("--help", () => {
+    printBanner();
+  });
+  program.command("index").description("Parse a JS/TS repo into the local embedded graph").argument("<path>", "Path to the repo root").option("--no-embed", "Skip the embedding pass (faster, no LLM calls)").action(async (repoPath, opts) => {
+    await runIndexCommand({ repoPath, noEmbed: opts.embed === false });
+  });
+  program.command("status").description("Show node/edge counts and embedding coverage for a repo").argument("<path>", "Path to the repo root").action(async (repoPath) => {
+    await runStatusCommand({ repoPath });
+  });
+  program.command("serve").description("Boot the local MCP server (default port 3748)").option("--port <port>", "TCP port to bind", (v) => Number(v)).option("--host <host>", "Host to bind (default 127.0.0.1)").option("--db-path <path>", "Override the embedded Kuzu graph directory").action(async (opts) => {
+    await runServeCommand({
+      ...opts.port !== void 0 ? { port: opts.port } : {},
+      ...opts.host !== void 0 ? { host: opts.host } : {},
+      ...opts.dbPath !== void 0 ? { dbPath: opts.dbPath } : {}
+    });
+  });
+  program.command("doctor").description("Check environment, config, LLM credentials, and Kuzu DB health").action(async () => {
+    await runDoctorCommand();
+  });
+  const configCmd = program.command("config").description("Manage ~/.codegraph/config.json");
+  configCmd.command("show").description("Print the resolved config").action(async () => {
+    await runConfigShow();
+  });
+  const llmCmd = configCmd.command("llm").description("Configure the LLM router");
+  llmCmd.command("set [preset]").description(
+    "Set LLM preset: managed-stub | byo-openai | byo-anthropic | byo-google | local-ollama. Omit the preset to pick interactively."
+  ).action(async (preset) => {
+    await runConfigLlmSet(preset);
+  });
+  llmCmd.command("test").description("Run a 5-token generation + 1 embedding call against the current config").action(async () => {
+    await runConfigLlmTest();
+  });
+  return program;
+}
+
+export {
+  configPath,
+  loadConfig,
+  saveConfig,
+  renderError,
+  buildProgram
+};
+//# sourceMappingURL=chunk-O4ZO6CP5.js.map