@leanlabsinnov/codegraph 0.1.2 → 0.1.4

package/dist/{chunk-36AWRLQ6.js → chunk-64OLVRK3.js}

@@ -1,17 +1,18 @@
 import {
   createLlmRouter,
   namespaceLabel
-} from "./chunk-B2TIVKUB.js";
+} from "./chunk-WXBYICTK.js";
 import {
   GraphDb,
   defaultDbPath
-} from "./chunk-2TORJYBO.js";
+} from "./chunk-AVQNLB4I.js";
 import {
   DEFAULT_CONFIG,
+  EDGE_KINDS,
   LLM_PRESETS,
   makeFileId,
   makeNodeId
-} from "./chunk-XGPZDCQ4.js";
+} from "./chunk-POGEFB23.js";
 
 // src/config-store.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
@@ -186,14 +187,15 @@ function friendlyHint(message) {
   }
   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, {
+function renderServeBanner(url, tokenHint, viewerUrl) {
+  const lines = [
+    `${kleur.green("\u2713")} codegraph mcp listening on ${kleur.cyan(url)}`
+  ];
+  if (viewerUrl) {
+    lines.push(`${kleur.green("\u2713")} graph viewer on          ${kleur.cyan(viewerUrl)}`);
+  }
+  lines.push("", kleur.dim(tokenHint), kleur.dim("Ctrl-C to stop."));
+  return boxen(lines.join("\n"), {
     padding: { top: 0, bottom: 0, left: 2, right: 2 },
     margin: { top: 1, bottom: 1, left: 0, right: 0 },
     borderColor: "green",
@@ -205,7 +207,7 @@ function renderServeBanner(url, tokenHint) {
 import { Command } from "commander";
 
 // src/commands/config.ts
-import { password, select } from "@inquirer/prompts";
+import { input, password, select } from "@inquirer/prompts";
 import kleur2 from "kleur";
 async function runConfigShow() {
   const config = await loadConfig();
@@ -231,10 +233,17 @@ async function runConfigLlmSet(presetArg) {
   }
   const config = await loadConfig();
   config.llm = { ...config.llm, ...lookup };
+  if (preset !== "local-openai-compatible") {
+    config.llm.baseUrl = void 0;
+  }
+  if (!presetArg && preset === "local-openai-compatible") {
+    const url = await promptBaseUrl();
+    if (url) config.llm.baseUrl = url;
+  }
   await saveConfig(config);
   console.log(kleur2.green(`\u2713 saved preset "${preset}" to ${configPath()}`));
   console.log(kleur2.dim(`embedding namespace: ${namespaceLabel(config.llm)}`));
-  if (!presetArg) {
+  if (!presetArg && preset !== "local-openai-compatible") {
     await maybePromptForApiKey(preset);
   }
 }
@@ -280,11 +289,28 @@ function describePreset(id) {
     case "byo-google":
       return "Gemini for gen + Google embeddings";
     case "local-ollama":
-      return "Fully local via Ollama (qwen2.5-coder + nomic-embed-text)";
+      return "Fully local via Ollama (qwen2.5-coder:1.5b + nomic-embed-text)";
+    case "local-openai-compatible":
+      return "Any OpenAI-compatible server (llama.cpp, LM Studio, vLLM) \u2014 you supply the URL";
     default:
       return "";
   }
 }
+async function promptBaseUrl() {
+  const url = await input({
+    message: "Server base URL (e.g. http://localhost:8080/v1):",
+    validate: (v) => v.trim() === "" || v.trim().startsWith("http") ? true : "Must be an http(s) URL (or leave empty to set later)"
+  });
+  const trimmed = url.trim();
+  if (!trimmed) {
+    console.log(
+      kleur2.yellow(
+        "! No URL saved. Edit ~/.codegraph/config.json to set llm.baseUrl before indexing."
+      )
+    );
+  }
+  return trimmed;
+}
 async function runConfigLlmTest() {
   const config = await loadConfig();
   console.log(kleur2.dim("testing llm config:"));
@@ -314,6 +340,43 @@ async function runConfigLlmTest() {
 import { access, constants, mkdir as mkdir2 } from "fs/promises";
 import { dirname } from "path";
 import kleur3 from "kleur";
+
+// src/ollama.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var LOCAL_MODELS = {
+  generation: "qwen2.5-coder:1.5b",
+  embeddings: "nomic-embed-text"
+};
+async function detectOllama() {
+  try {
+    const res = await fetch("http://localhost:11434/api/tags", {
+      signal: AbortSignal.timeout(800)
+    });
+    if (res.ok) {
+      const data = await res.json();
+      const models = (data.models ?? []).map((m) => m.name);
+      const neededPrefixes = [
+        LOCAL_MODELS.generation.split(":")[0],
+        LOCAL_MODELS.embeddings
+      ];
+      const hasAll = neededPrefixes.every(
+        (prefix) => models.some((m) => m.startsWith(prefix))
+      );
+      return hasAll ? { status: "ready", models } : { status: "running-no-models", models };
+    }
+  } catch {
+  }
+  try {
+    await execFileAsync("ollama", ["--version"], { timeout: 2e3 });
+    return { status: "installed-not-running" };
+  } catch {
+  }
+  return { status: "not-installed" };
+}
+
+// src/commands/doctor.ts
 async function runDoctorCommand() {
   const checks = [];
   checks.push(checkNodeVersion());
@@ -336,6 +399,9 @@ async function runDoctorCommand() {
       checks.push(checkApiKey(config.llm.embeddings.provider));
     }
   }
+  if (config && config.llm.generation.provider === "ollama") {
+    checks.push(await checkOllamaDaemon());
+  }
   if (config) {
     checks.push(await selfTestLlm(config));
     checks.push(await selfTestKuzu(dbPath, config.llm.embeddings.dimension));
@@ -374,20 +440,20 @@ function checkNodeVersion() {
     detail: `v${version} (codegraph requires >= 20)`
   };
 }
-async function checkWritable(name, path6) {
+async function checkWritable(name, path8) {
   try {
-    await mkdir2(dirname(path6), { recursive: true });
+    await mkdir2(dirname(path8), { recursive: true });
     try {
-      await access(path6, constants.W_OK);
+      await access(path8, constants.W_OK);
     } catch {
-      await access(dirname(path6), constants.W_OK);
+      await access(dirname(path8), constants.W_OK);
     }
-    return { name, status: "ok", detail: path6 };
+    return { name, status: "ok", detail: path8 };
   } catch (err) {
     return {
       name,
       status: "fail",
-      detail: `${path6} (${err instanceof Error ? err.message : String(err)})`
+      detail: `${path8} (${err instanceof Error ? err.message : String(err)})`
     };
   }
 }
@@ -411,6 +477,31 @@ function providerEnvVar(provider) {
   if (provider === "google") return "GOOGLE_GENERATIVE_AI_API_KEY";
   return null;
 }
+async function checkOllamaDaemon() {
+  const s = await detectOllama();
+  switch (s.status) {
+    case "ready":
+      return { name: "ollama daemon", status: "ok", detail: "running, models present" };
+    case "running-no-models":
+      return {
+        name: "ollama daemon",
+        status: "warn",
+        detail: `running \u2014 pull missing models: ollama pull ${LOCAL_MODELS.generation} && ollama pull ${LOCAL_MODELS.embeddings}`
+      };
+    case "installed-not-running":
+      return {
+        name: "ollama daemon",
+        status: "fail",
+        detail: "installed but not running \u2014 start with `ollama serve`"
+      };
+    case "not-installed":
+      return {
+        name: "ollama daemon",
+        status: "fail",
+        detail: "not installed \u2014 see https://ollama.com"
+      };
+  }
+}
 async function selfTestLlm(config) {
   try {
     const router = await createLlmRouter({ config: config.llm });
@@ -458,7 +549,8 @@ async function selfTestKuzu(dbPath, embeddingDimension) {
 }
 
 // src/commands/index.ts
-import path5 from "path";
+import { rm } from "fs/promises";
+import path6 from "path";
 
 // ../ingestion/src/parser.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -470,7 +562,8 @@ var GRAMMAR_FILE = {
   typescript: "tree-sitter-typescript.wasm",
   tsx: "tree-sitter-tsx.wasm",
   javascript: "tree-sitter-javascript.wasm",
-  jsx: "tree-sitter-javascript.wasm"
+  jsx: "tree-sitter-javascript.wasm",
+  python: "tree-sitter-python.wasm"
 };
 var initPromise = null;
 var languageCache = /* @__PURE__ */ new Map();
@@ -509,6 +602,8 @@ function detectLanguage(filePath) {
       return "javascript";
     case ".jsx":
       return "jsx";
+    case ".py":
+      return "python";
     default:
       return null;
   }
@@ -530,8 +625,8 @@ async function parseSource(source, language) {
 }
 
 // ../ingestion/src/extractors/extract.ts
-import { createHash } from "crypto";
-import { basename } from "path";
+import { createHash as createHash2 } from "crypto";
+import { basename as basename2 } from "path";
 
 // ../ingestion/src/walker.ts
 function* walk(node) {
@@ -590,6 +685,325 @@ function isPascalCase(name) {
   return /^[A-Z][A-Za-z0-9]*$/.test(name);
 }
 
+// ../ingestion/src/extractors/extract-python.ts
+import { createHash } from "crypto";
+import { basename } from "path";
+async function extractPythonFile(input3) {
+  const parsed = await parseSource(input3.source, input3.language);
+  const fileId = makeFileId({ repoId: input3.repoId, path: input3.relativePath });
+  const file = {
+    id: fileId,
+    kind: "File",
+    repoId: input3.repoId,
+    name: basename(input3.relativePath),
+    path: input3.relativePath,
+    lineStart: 1,
+    lineEnd: Math.max(1, parsed.rootNode.endPosition.row + 1),
+    language: input3.language,
+    sizeBytes: Buffer.byteLength(input3.source, "utf8"),
+    contentHash: sha1(input3.source)
+  };
+  const nodes = [];
+  const edges = [];
+  const localSymbols = /* @__PURE__ */ new Map();
+  for (const node of walk(parsed.rootNode)) {
+    const symbol = extractPythonSymbol(node, input3, 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 });
+    }
+    for (const parent of symbol.parentClasses ?? []) {
+      edges.push({
+        kind: "INHERITS",
+        fromId: symbol.node.id,
+        toId: "",
+        unresolvedTargetName: parent
+      });
+    }
+  }
+  for (const node of walk(parsed.rootNode)) {
+    if (node.type === "import_statement") {
+      for (const moduleNode of moduleNamesInImport(node)) {
+        const spec = dottedNameToPath(moduleNode, parsed.source);
+        if (!spec) continue;
+        edges.push({
+          kind: "IMPORTS",
+          fromId: fileId,
+          toId: "",
+          line: startLine(node),
+          fromPath: input3.relativePath,
+          toPath: spec,
+          unresolvedTargetName: spec
+        });
+      }
+    } else if (node.type === "import_from_statement") {
+      const moduleNode = node.childForFieldName("module_name");
+      if (!moduleNode) continue;
+      const spec = moduleSpecFromFromImport(moduleNode, parsed.source);
+      if (!spec) continue;
+      edges.push({
+        kind: "IMPORTS",
+        fromId: fileId,
+        toId: "",
+        line: startLine(node),
+        fromPath: input3.relativePath,
+        toPath: spec,
+        unresolvedTargetName: spec
+      });
+    }
+  }
+  for (const node of walk(parsed.rootNode)) {
+    if (node.type !== "call") continue;
+    const callee = node.childForFieldName("function");
+    if (!callee) continue;
+    const calleeName = extractCalleeName(callee, parsed.source);
+    if (!calleeName) continue;
+    const enclosing = findEnclosingPythonSymbolId(node, localSymbols, parsed.source);
+    if (!enclosing) continue;
+    edges.push({
+      kind: "CALLS",
+      fromId: enclosing,
+      toId: "",
+      line: startLine(node),
+      unresolvedTargetName: calleeName
+    });
+  }
+  return { file, nodes, edges };
+}
+function extractPythonSymbol(node, input3, source) {
+  switch (node.type) {
+    case "function_definition":
+      return pythonFunction(node, input3, source);
+    case "class_definition":
+      return pythonClass(node, input3, source);
+    case "assignment":
+      return pythonModuleVariable(node, input3, source);
+    default:
+      return null;
+  }
+}
+function pythonFunction(node, input3, source) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const name = nodeText(nameNode, source);
+  const line = startLine(node);
+  const id = makeNodeId({
+    repoId: input3.repoId,
+    kind: "Function",
+    path: input3.relativePath,
+    name,
+    line
+  });
+  return {
+    node: {
+      id,
+      kind: "Function",
+      repoId: input3.repoId,
+      name,
+      path: input3.relativePath,
+      lineStart: decoratedLineStart(node),
+      lineEnd: endLine(node),
+      signature: pythonDefSignature(node, source, "def"),
+      leadingComment: pythonDocstring(node, source),
+      isExported: isPythonExported(name),
+      isAsync: isAsyncFunctionDef(node, source)
+    }
+  };
+}
+function pythonClass(node, input3, source) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return null;
+  const name = nodeText(nameNode, source);
+  const line = startLine(node);
+  const id = makeNodeId({
+    repoId: input3.repoId,
+    kind: "Class",
+    path: input3.relativePath,
+    name,
+    line
+  });
+  const parents = extractPythonBaseClasses(node, source);
+  return {
+    node: {
+      id,
+      kind: "Class",
+      repoId: input3.repoId,
+      name,
+      path: input3.relativePath,
+      lineStart: decoratedLineStart(node),
+      lineEnd: endLine(node),
+      signature: pythonDefSignature(node, source, "class"),
+      leadingComment: pythonDocstring(node, source),
+      isExported: isPythonExported(name)
+    },
+    ...parents.length > 0 ? { parentClasses: parents } : {}
+  };
+}
+function pythonModuleVariable(node, input3, source) {
+  const stmtParent = node.parent;
+  if (!stmtParent || stmtParent.type !== "expression_statement") return null;
+  const moduleParent = stmtParent.parent;
+  if (!moduleParent || moduleParent.type !== "module") return null;
+  const left = node.childForFieldName("left");
+  if (!left || left.type !== "identifier") return null;
+  const name = nodeText(left, source);
+  const line = startLine(node);
+  const id = makeNodeId({
+    repoId: input3.repoId,
+    kind: "Variable",
+    path: input3.relativePath,
+    name,
+    line
+  });
+  return {
+    node: {
+      id,
+      kind: "Variable",
+      repoId: input3.repoId,
+      name,
+      path: input3.relativePath,
+      lineStart: line,
+      lineEnd: endLine(node),
+      signature: nodeText(node, source).split("\n")[0]?.slice(0, 200) ?? "",
+      isExported: isPythonExported(name)
+    }
+  };
+}
+function isPythonExported(name) {
+  return !name.startsWith("_");
+}
+function isAsyncFunctionDef(node, source) {
+  return nodeText(node, source).trimStart().startsWith("async");
+}
+function decoratedLineStart(node) {
+  const parent = node.parent;
+  if (parent && parent.type === "decorated_definition") {
+    return startLine(parent);
+  }
+  return startLine(node);
+}
+function pythonDefSignature(node, source, keyword) {
+  const text = nodeText(node, source);
+  const firstLine = text.split("\n")[0]?.trim() ?? "";
+  const cleaned = firstLine.replace(/:\s*$/, "");
+  if (cleaned.length > 0) return cleaned.slice(0, 200);
+  return `${keyword} ?`;
+}
+function pythonDocstring(node, source) {
+  const body = node.childForFieldName("body");
+  if (!body) return "";
+  const firstStmt = body.namedChild(0);
+  if (!firstStmt || firstStmt.type !== "expression_statement") return "";
+  const expr = firstStmt.namedChild(0);
+  if (!expr || expr.type !== "string") return "";
+  const raw = nodeText(expr, source);
+  return stripPythonStringQuotes(raw).trim();
+}
+function stripPythonStringQuotes(raw) {
+  const withoutPrefix = raw.replace(/^[rRbBuUfF]+/, "");
+  if (withoutPrefix.startsWith('"""') && withoutPrefix.endsWith('"""')) {
+    return withoutPrefix.slice(3, -3);
+  }
+  if (withoutPrefix.startsWith("'''") && withoutPrefix.endsWith("'''")) {
+    return withoutPrefix.slice(3, -3);
+  }
+  if (withoutPrefix.startsWith('"') && withoutPrefix.endsWith('"') || withoutPrefix.startsWith("'") && withoutPrefix.endsWith("'")) {
+    return withoutPrefix.slice(1, -1);
+  }
+  return withoutPrefix;
+}
+function extractPythonBaseClasses(node, source) {
+  const supers = node.childForFieldName("superclasses");
+  if (!supers) return [];
+  const out = [];
+  for (let i = 0; i < supers.namedChildCount; i++) {
+    const arg = supers.namedChild(i);
+    if (!arg) continue;
+    if (arg.type === "keyword_argument") continue;
+    const name = extractCalleeName(arg, source);
+    if (name) out.push(name);
+  }
+  return out;
+}
+function moduleNamesInImport(importNode) {
+  const out = [];
+  for (let i = 0; i < importNode.namedChildCount; i++) {
+    const child = importNode.namedChild(i);
+    if (!child) continue;
+    if (child.type === "dotted_name") {
+      out.push(child);
+    } else if (child.type === "aliased_import") {
+      const inner = child.childForFieldName("name") ?? findChildByType(child, "dotted_name");
+      if (inner) out.push(inner);
+    }
+  }
+  return out;
+}
+function dottedNameToPath(node, source) {
+  if (node.type !== "dotted_name") return null;
+  const segments = [];
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const ident = node.namedChild(i);
+    if (!ident) continue;
+    segments.push(nodeText(ident, source));
+  }
+  if (segments.length === 0) return null;
+  return segments.join("/");
+}
+function moduleSpecFromFromImport(moduleNode, source) {
+  if (moduleNode.type === "dotted_name") {
+    return dottedNameToPath(moduleNode, source);
+  }
+  if (moduleNode.type !== "relative_import") return null;
+  let dotCount = 0;
+  let dottedSpec = null;
+  for (let i = 0; i < moduleNode.childCount; i++) {
+    const child = moduleNode.child(i);
+    if (!child) continue;
+    if (child.type === "import_prefix") {
+      dotCount = nodeText(child, source).length;
+    } else if (child.type === "dotted_name") {
+      dottedSpec = dottedNameToPath(child, source);
+    }
+  }
+  if (dotCount === 0) return dottedSpec;
+  const upHops = "../".repeat(Math.max(0, dotCount - 1));
+  const base = upHops.length > 0 ? upHops.slice(0, -1) : ".";
+  if (dottedSpec) return `${base}/${dottedSpec}`;
+  return base;
+}
+function extractCalleeName(node, source) {
+  if (node.type === "identifier") {
+    return nodeText(node, source);
+  }
+  if (node.type === "attribute") {
+    const attr = node.childForFieldName("attribute");
+    if (attr && attr.type === "identifier") return nodeText(attr, source);
+    return null;
+  }
+  return null;
+}
+function findEnclosingPythonSymbolId(node, localSymbols, source) {
+  let cursor = node.parent;
+  while (cursor) {
+    if (cursor.type === "function_definition" || cursor.type === "class_definition") {
+      const nameNode = cursor.childForFieldName("name");
+      if (nameNode) {
+        const id = localSymbols.get(nodeText(nameNode, source));
+        if (id) return id;
+      }
+    }
+    cursor = cursor.parent;
+  }
+  return null;
+}
+function sha1(text) {
+  return createHash("sha1").update(text).digest("hex");
+}
+
 // ../ingestion/src/extractors/routes.ts
 var EXPRESS_METHODS = /* @__PURE__ */ new Set([
   "get",
@@ -611,44 +1025,44 @@ var HTTP_VERBS = /* @__PURE__ */ new Set([
   "OPTIONS",
   "HEAD"
 ]);
-function detectRoutes(input) {
+function detectRoutes(input3) {
   return [
-    ...detectExpressRoutes(input),
-    ...detectNextAppRouterRoutes(input),
-    ...detectNextPagesApiRoutes(input)
+    ...detectExpressRoutes(input3),
+    ...detectNextAppRouterRoutes(input3),
+    ...detectNextPagesApiRoutes(input3)
   ];
 }
-function detectExpressRoutes(input) {
+function detectExpressRoutes(input3) {
   const out = [];
-  for (const node of walk(input.rootNode)) {
+  for (const node of walk(input3.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();
+    const method = nodeText(prop, input3.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));
+    const routePath = stripQuotes(nodeText(firstArg, input3.source));
     if (!routePath.startsWith("/")) continue;
     const line = startLine(node);
     const name = `${method.toUpperCase()} ${routePath}`;
     out.push({
       id: makeNodeId({
-        repoId: input.repoId,
+        repoId: input3.repoId,
         kind: "Route",
-        path: input.relativePath,
+        path: input3.relativePath,
         name,
         line
       }),
       kind: "Route",
-      repoId: input.repoId,
+      repoId: input3.repoId,
       name,
-      path: input.relativePath,
+      path: input3.relativePath,
       lineStart: line,
       lineEnd: endLine(node),
       method: method.toUpperCase(),
@@ -658,29 +1072,29 @@ function detectExpressRoutes(input) {
   }
   return out;
 }
-function detectNextAppRouterRoutes(input) {
-  if (!/(^|\/)app\/.+\/route\.(ts|tsx|js|jsx|mjs|cjs)$/.test(input.relativePath)) return [];
-  const routePath = appRoutePathFor(input.relativePath);
+function detectNextAppRouterRoutes(input3) {
+  if (!/(^|\/)app\/.+\/route\.(ts|tsx|js|jsx|mjs|cjs)$/.test(input3.relativePath)) return [];
+  const routePath = appRoutePathFor(input3.relativePath);
   const out = [];
-  for (const node of walk(input.rootNode)) {
+  for (const node of walk(input3.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);
+    const name = extractTopLevelName(decl, input3.source);
     if (!name || !HTTP_VERBS.has(name)) continue;
     const line = startLine(node);
     out.push({
       id: makeNodeId({
-        repoId: input.repoId,
+        repoId: input3.repoId,
         kind: "Route",
-        path: input.relativePath,
+        path: input3.relativePath,
         name: `${name} ${routePath}`,
         line
       }),
       kind: "Route",
-      repoId: input.repoId,
+      repoId: input3.repoId,
       name: `${name} ${routePath}`,
-      path: input.relativePath,
+      path: input3.relativePath,
       lineStart: line,
       lineEnd: endLine(node),
       method: name,
@@ -690,27 +1104,27 @@ function detectNextAppRouterRoutes(input) {
   }
   return out;
 }
-function detectNextPagesApiRoutes(input) {
-  if (!/(^|\/)pages\/api\//.test(input.relativePath)) return [];
-  const routePath = pagesApiPathFor(input.relativePath);
-  for (const node of walk(input.rootNode)) {
+function detectNextPagesApiRoutes(input3) {
+  if (!/(^|\/)pages\/api\//.test(input3.relativePath)) return [];
+  const routePath = pagesApiPathFor(input3.relativePath);
+  for (const node of walk(input3.rootNode)) {
     if (node.type !== "export_statement") continue;
-    const text = nodeText(node, input.source);
+    const text = nodeText(node, input3.source);
     if (!/default/.test(text)) continue;
     const line = startLine(node);
     return [
       {
         id: makeNodeId({
-          repoId: input.repoId,
+          repoId: input3.repoId,
           kind: "Route",
-          path: input.relativePath,
+          path: input3.relativePath,
           name: `ANY ${routePath}`,
           line
         }),
         kind: "Route",
-        repoId: input.repoId,
+        repoId: input3.repoId,
         name: `ANY ${routePath}`,
-        path: input.relativePath,
+        path: input3.relativePath,
         lineStart: line,
         lineEnd: endLine(node),
         method: "ANY",
@@ -754,26 +1168,32 @@ function pagesApiPathFor(relativePath) {
 }
 
 // ../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 });
+async function extractFile(input3) {
+  if (input3.language === "python") {
+    return extractPythonFile(input3);
+  }
+  return extractJsTsFile(input3);
+}
+async function extractJsTsFile(input3) {
+  const parsed = await parseSource(input3.source, input3.language);
+  const fileId = makeFileId({ repoId: input3.repoId, path: input3.relativePath });
   const file = {
     id: fileId,
     kind: "File",
-    repoId: input.repoId,
-    name: basename(input.relativePath),
-    path: input.relativePath,
+    repoId: input3.repoId,
+    name: basename2(input3.relativePath),
+    path: input3.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)
+    language: input3.language,
+    sizeBytes: Buffer.byteLength(input3.source, "utf8"),
+    contentHash: sha12(input3.source)
   };
   const nodes = [];
   const edges = [];
   const localSymbols = /* @__PURE__ */ new Map();
   for (const node of walk(parsed.rootNode)) {
-    const symbol = extractSymbol(node, input, parsed.source);
+    const symbol = extractSymbol(node, input3, parsed.source);
     if (!symbol) continue;
     nodes.push(symbol.node);
     localSymbols.set(symbol.node.name, symbol.node.id);
@@ -801,7 +1221,7 @@ async function extractFile(input) {
         fromId: fileId,
         toId: "",
         line: startLine(node),
-        fromPath: input.relativePath,
+        fromPath: input3.relativePath,
         toPath: target,
         unresolvedTargetName: target
       });
@@ -811,9 +1231,9 @@ async function extractFile(input) {
     if (node.type !== "call_expression") continue;
     const callee = node.childForFieldName("function");
     if (!callee) continue;
-    const calleeName = extractCalleeName(callee, parsed.source);
+    const calleeName = extractCalleeName2(callee, parsed.source);
     if (!calleeName) continue;
-    const enclosing = findEnclosingSymbolId(node, input, parsed.source, localSymbols);
+    const enclosing = findEnclosingSymbolId(node, input3, parsed.source, localSymbols);
     if (!enclosing) continue;
     edges.push({
       kind: "CALLS",
@@ -823,14 +1243,14 @@ async function extractFile(input) {
       unresolvedTargetName: calleeName
     });
   }
-  if (input.language === "tsx" || input.language === "jsx") {
+  if (input3.language === "tsx" || input3.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);
+      const enclosing = findEnclosingSymbolId(node, input3, parsed.source, localSymbols);
       if (!enclosing) continue;
       edges.push({
         kind: "RENDERS",
@@ -842,13 +1262,13 @@ async function extractFile(input) {
     }
   }
   const routes = detectRoutes({
-    repoId: input.repoId,
-    relativePath: input.relativePath,
-    absolutePath: input.absolutePath,
+    repoId: input3.repoId,
+    relativePath: input3.relativePath,
+    absolutePath: input3.absolutePath,
     fileId,
     rootNode: parsed.rootNode,
     source: parsed.source,
-    language: input.language
+    language: input3.language
   });
   for (const route of routes) {
     nodes.push(route);
@@ -856,53 +1276,55 @@ async function extractFile(input) {
   }
   return { file, nodes, edges };
 }
-function extractSymbol(node, input, source) {
+function extractSymbol(node, input3, source) {
   switch (node.type) {
     case "function_declaration":
     case "generator_function_declaration":
-      return functionFromDeclaration(node, input, source);
+      return functionFromDeclaration(node, input3, source);
     case "class_declaration":
-      return classFromDeclaration(node, input, source);
+      return classFromDeclaration(node, input3, source);
     case "interface_declaration":
-      return interfaceFromDeclaration(node, input, source, "Interface");
+      return interfaceFromDeclaration(node, input3, source, "Interface");
     case "type_alias_declaration":
-      return interfaceFromDeclaration(node, input, source, "Interface");
+      return interfaceFromDeclaration(node, input3, source, "Interface");
     case "lexical_declaration":
     case "variable_declaration":
-      return variableOrArrowFromDeclaration(node, input, source);
+      return variableOrArrowFromDeclaration(node, input3, source);
     default:
       return null;
   }
 }
-function functionFromDeclaration(node, input, source) {
+function functionFromDeclaration(node, input3, source) {
   const nameNode = node.childForFieldName("name");
   if (!nameNode) return null;
   const name = nodeText(nameNode, source);
   const line = startLine(node);
+  const isComponent = (input3.language === "tsx" || input3.language === "jsx") && isPascalCase(name) && containsJsx(node.childForFieldName("body"));
+  const kind = isComponent ? "Component" : "Function";
   const id = makeNodeId({
-    repoId: input.repoId,
-    kind: "Function",
-    path: input.relativePath,
+    repoId: input3.repoId,
+    kind,
+    path: input3.relativePath,
     name,
     line
   });
   return {
     node: {
       id,
-      kind: "Function",
-      repoId: input.repoId,
+      kind,
+      repoId: input3.repoId,
       name,
-      path: input.relativePath,
+      path: input3.relativePath,
       lineStart: line,
       lineEnd: endLine(node),
       signature: extractSignature(node, source),
       leadingComment: leadingCommentFor(parentForLeadingComment(node), source),
       isExported: isExported(node),
-      isAsync: hasAsyncModifier(node, source)
+      ...kind === "Function" ? { isAsync: hasAsyncModifier(node, source) } : {}
     }
   };
 }
-function classFromDeclaration(node, input, source) {
+function classFromDeclaration(node, input3, source) {
   const nameNode = node.childForFieldName("name");
   if (!nameNode) return null;
   const name = nodeText(nameNode, source);
@@ -910,9 +1332,9 @@ function classFromDeclaration(node, input, source) {
   const isComponent = looksLikeComponentClass(node, name, source);
   const kind = isComponent ? "Component" : "Class";
   const id = makeNodeId({
-    repoId: input.repoId,
+    repoId: input3.repoId,
     kind,
-    path: input.relativePath,
+    path: input3.relativePath,
     name,
     line
   });
@@ -921,9 +1343,9 @@ function classFromDeclaration(node, input, source) {
     node: {
       id,
       kind,
-      repoId: input.repoId,
+      repoId: input3.repoId,
       name,
-      path: input.relativePath,
+      path: input3.relativePath,
       lineStart: line,
       lineEnd: endLine(node),
       signature: `class ${name}${parentClass ? ` extends ${parentClass}` : ""}`,
@@ -933,15 +1355,15 @@ function classFromDeclaration(node, input, source) {
     ...parentClass !== void 0 ? { parentClass } : {}
   };
 }
-function interfaceFromDeclaration(node, input, source, kind) {
+function interfaceFromDeclaration(node, input3, 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,
+    repoId: input3.repoId,
     kind,
-    path: input.relativePath,
+    path: input3.relativePath,
     name,
     line
   });
@@ -949,9 +1371,9 @@ function interfaceFromDeclaration(node, input, source, kind) {
     node: {
       id,
       kind,
-      repoId: input.repoId,
+      repoId: input3.repoId,
       name,
-      path: input.relativePath,
+      path: input3.relativePath,
       lineStart: line,
       lineEnd: endLine(node),
       signature: nodeText(node, source).split("\n")[0]?.slice(0, 200) ?? "",
@@ -960,7 +1382,7 @@ function interfaceFromDeclaration(node, input, source, kind) {
     }
   };
 }
-function variableOrArrowFromDeclaration(node, input, source) {
+function variableOrArrowFromDeclaration(node, input3, source) {
   const declarators = findChildrenByType(node, "variable_declarator");
   if (declarators.length === 0) return null;
   const decl = declarators[0];
@@ -968,6 +1390,9 @@ function variableOrArrowFromDeclaration(node, input, source) {
   const nameNode = decl.childForFieldName("name");
   const value = decl.childForFieldName("value");
   if (!nameNode) return null;
+  if (nameNode.type !== "identifier" && nameNode.type !== "property_identifier") {
+    return null;
+  }
   const name = nodeText(nameNode, source);
   const line = startLine(decl);
   const isArrow = value?.type === "arrow_function" || value?.type === "function_expression";
@@ -975,9 +1400,9 @@ function variableOrArrowFromDeclaration(node, input, source) {
     const isComponent = isPascalCase(name) && containsJsx(value);
     const kind = isComponent ? "Component" : "Function";
     const id2 = makeNodeId({
-      repoId: input.repoId,
+      repoId: input3.repoId,
       kind,
-      path: input.relativePath,
+      path: input3.relativePath,
       name,
       line
     });
@@ -985,9 +1410,9 @@ function variableOrArrowFromDeclaration(node, input, source) {
       node: {
         id: id2,
         kind,
-        repoId: input.repoId,
+        repoId: input3.repoId,
         name,
-        path: input.relativePath,
+        path: input3.relativePath,
         lineStart: line,
         lineEnd: endLine(decl),
         signature: extractSignature(value, source),
@@ -998,9 +1423,9 @@ function variableOrArrowFromDeclaration(node, input, source) {
     };
   }
   const id = makeNodeId({
-    repoId: input.repoId,
+    repoId: input3.repoId,
     kind: "Variable",
-    path: input.relativePath,
+    path: input3.relativePath,
     name,
     line
   });
@@ -1008,9 +1433,9 @@ function variableOrArrowFromDeclaration(node, input, source) {
     node: {
       id,
       kind: "Variable",
-      repoId: input.repoId,
+      repoId: input3.repoId,
       name,
-      path: input.relativePath,
+      path: input3.relativePath,
       lineStart: line,
       lineEnd: endLine(decl),
       signature: nodeText(decl, source).split("\n")[0]?.slice(0, 200) ?? "",
@@ -1029,9 +1454,13 @@ function extractSignature(node, source) {
   const rs = ret ? ` ${nodeText(ret, source)}` : "";
   return `${head}${ps}${rs}`.trim().slice(0, 200);
 }
-function extractCalleeName(callee, source) {
+function extractCalleeName2(callee, source) {
   if (callee.type === "identifier") return nodeText(callee, source);
   if (callee.type === "member_expression") {
+    const object = callee.childForFieldName("object");
+    if (object && object.type === "identifier") {
+      return nodeText(object, source);
+    }
     const property = callee.childForFieldName("property");
     if (property) return nodeText(property, source);
   }
@@ -1088,7 +1517,7 @@ function parentForLeadingComment(node) {
   }
   return cursor;
 }
-function findEnclosingSymbolId(node, input, source, localSymbols) {
+function findEnclosingSymbolId(node, input3, 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") {
@@ -1100,7 +1529,7 @@ function findEnclosingSymbolId(node, input, source, localSymbols) {
     }
     cursor = cursor.parent;
   }
-  return makeFileId({ repoId: input.repoId, path: input.relativePath });
+  return makeFileId({ repoId: input3.repoId, path: input3.relativePath });
 }
 function enclosingDeclarationName(node, source) {
   const nameField = node.childForFieldName("name");
@@ -1117,22 +1546,31 @@ function enclosingDeclarationName(node, source) {
   }
   return null;
 }
-function sha1(s) {
-  return createHash("sha1").update(s).digest("hex");
+function sha12(s) {
+  return createHash2("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) {
+var EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"];
+var DIRECTORY_INDEX_FILES = [
+  "index.ts",
+  "index.tsx",
+  "index.js",
+  "index.jsx",
+  "index.mjs",
+  "index.cjs",
+  "__init__.py"
+];
+function resolveEdges(input3) {
   const byName = /* @__PURE__ */ new Map();
-  for (const n of input.nodes) {
+  for (const n of input3.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) {
+  for (const edge of input3.edges) {
     if (edge.toId) {
       out.push(edge);
       continue;
@@ -1143,16 +1581,17 @@ function resolveEdges(input) {
     }
     if (edge.kind === "IMPORTS") {
       const resolved = resolveImportPath({
-        repoId: input.repoId,
+        repoId: input3.repoId,
         fromPath: edge.fromPath ?? "",
         spec: edge.unresolvedTargetName,
-        known: input.knownFilePaths
+        known: input3.knownFilePaths,
+        ...input3.tsconfigPaths ? { tsconfigPaths: input3.tsconfigPaths } : {}
       });
       if (!resolved) {
         dropped++;
         continue;
       }
-      const targetId2 = makeFileId({ repoId: input.repoId, path: resolved });
+      const targetId2 = makeFileId({ repoId: input3.repoId, path: resolved });
       const { unresolvedTargetName: _unused2, ...rest2 } = edge;
       out.push({ ...rest2, toId: targetId2, toPath: resolved });
       continue;
@@ -1167,30 +1606,69 @@ function resolveEdges(input) {
   }
   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)));
+function resolveImportPath(input3) {
+  const { fromPath, spec, known, tsconfigPaths } = input3;
+  if (spec.startsWith(".") || spec.startsWith("/")) {
+    const baseDir = path2.posix.dirname(toPosix(fromPath));
+    const joined = path2.posix.normalize(path2.posix.join(baseDir, toPosix(spec)));
+    return firstMatchingCandidate(joined, known);
+  }
+  if (tsconfigPaths) {
+    const candidates = expandAliasCandidates(spec, tsconfigPaths);
+    for (const c of candidates) {
+      const resolved = firstMatchingCandidate(c, known);
+      if (resolved) return resolved;
+    }
+  }
+  const fromRoot = firstMatchingCandidate(toPosix(spec), known);
+  if (fromRoot) return fromRoot;
+  return null;
+}
+function firstMatchingCandidate(joined, known) {
   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 indexFile of DIRECTORY_INDEX_FILES) candidates.push(`${stem}/${indexFile}`);
   for (const c of candidates) {
     if (known.has(c)) return c;
   }
   return null;
 }
+function expandAliasCandidates(spec, cfg) {
+  const sortedPatterns = Object.keys(cfg.paths).sort((a, b) => b.length - a.length);
+  const out = [];
+  for (const pattern of sortedPatterns) {
+    const replacements = cfg.paths[pattern] ?? [];
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -1);
+      if (!spec.startsWith(prefix)) continue;
+      const tail = spec.slice(prefix.length);
+      for (const r of replacements) {
+        const rTail = r.endsWith("/*") ? r.slice(0, -1) : r.endsWith("*") ? r.slice(0, -1) : r;
+        const joined = path2.posix.normalize(
+          path2.posix.join(toPosix(cfg.baseUrl), `${rTail}${tail}`)
+        );
+        out.push(joined);
+      }
+    } else if (spec === pattern) {
+      for (const r of replacements) {
+        const joined = path2.posix.normalize(path2.posix.join(toPosix(cfg.baseUrl), r));
+        out.push(joined);
+      }
+    }
+  }
+  return out;
+}
 function toPosix(p) {
   return p.split(path2.sep).join("/");
 }
 
 // ../ingestion/src/orchestrator.ts
-import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import { readFile as readFile5, stat as stat2 } from "fs/promises";
 import { cpus } from "os";
 import { join as join2 } from "path";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import ignore2 from "ignore";
 
 // ../ingestion/src/embedder.ts
@@ -1204,8 +1682,8 @@ ${comment}`.trim();
 async function embedNodes(nodes, opts) {
   const batchSize = opts.batchSize ?? 100;
   const candidates = nodes.filter((n) => n.kind !== "File");
+  const totalSymbols = candidates.length;
   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);
@@ -1219,32 +1697,134 @@ async function embedNodes(nodes, opts) {
     }
     opts.onBatch?.({
       batchIndex: i / batchSize,
-      total,
+      total: totalSymbols,
       embedded: result.length
     });
   }
   return result;
 }
 
-// ../ingestion/src/repo-walker.ts
-import { readFile as readFile3, readdir, stat } from "fs/promises";
+// ../ingestion/src/tsconfig.ts
+import { readFile as readFile3 } from "fs/promises";
 import path3 from "path";
+async function loadTsconfigPaths(repoRoot) {
+  for (const name of ["tsconfig.json", "jsconfig.json"]) {
+    const raw = await readIfExists(path3.join(repoRoot, name));
+    if (!raw) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(stripJsonComments(raw));
+    } catch {
+      continue;
+    }
+    const co = parsed.compilerOptions ?? {};
+    const paths = co.paths ?? {};
+    if (Object.keys(paths).length === 0) continue;
+    const baseUrl = (co.baseUrl ?? ".").trim();
+    return {
+      baseUrl: toPosix2(baseUrl),
+      paths
+    };
+  }
+  return null;
+}
+async function readIfExists(filePath) {
+  try {
+    return await readFile3(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function stripJsonComments(input3) {
+  let out = "";
+  let i = 0;
+  let inString = false;
+  let stringChar = "";
+  while (i < input3.length) {
+    const c = input3[i];
+    const next = input3[i + 1];
+    if (inString) {
+      out += c;
+      if (c === "\\" && next !== void 0) {
+        out += next;
+        i += 2;
+        continue;
+      }
+      if (c === stringChar) inString = false;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      inString = true;
+      stringChar = c;
+      out += c;
+      i++;
+      continue;
+    }
+    if (c === "/" && next === "/") {
+      while (i < input3.length && input3[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      i += 2;
+      while (i < input3.length && !(input3[i] === "*" && input3[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return removeTrailingCommas(out);
+}
+function removeTrailingCommas(s) {
+  return s.replace(/,\s*([}\]])/g, "$1");
+}
+function toPosix2(p) {
+  return p.split(path3.sep).join("/");
+}
+
+// ../ingestion/src/repo-walker.ts
+import { readFile as readFile4, readdir, stat } from "fs/promises";
+import path4 from "path";
 import ignore from "ignore";
 var ALWAYS_SKIP_DIRS = /* @__PURE__ */ new Set([
   ".git",
+  ".hg",
+  ".svn",
   "node_modules",
   ".next",
+  ".nuxt",
+  ".svelte-kit",
   "dist",
   "build",
   "out",
   ".turbo",
   ".cache",
+  ".parcel-cache",
   "coverage",
+  ".nyc_output",
   ".idea",
-  ".vscode"
+  ".vscode",
+  ".vs",
+  "venv",
+  ".venv",
+  "env",
+  "__pycache__",
+  "site-packages",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  ".tox",
+  ".eggs",
+  "target",
+  "vendor",
+  "Pods",
+  "DerivedData",
+  ".gradle",
+  ".terraform"
 ]);
 async function walkRepo(root) {
-  const base = path3.resolve(root);
+  const base = path4.resolve(root);
   const matcher = ignore();
   await loadGitignoreInto(matcher, base);
   const out = [];
@@ -1261,7 +1841,7 @@ async function walkDir(absDir, relDir, ig, out) {
   for (const entry of entries) {
     const name = entry.name;
     const rel = relDir ? `${relDir}/${name}` : name;
-    const abs = path3.join(absDir, name);
+    const abs = path4.join(absDir, name);
     if (entry.isDirectory()) {
       if (ALWAYS_SKIP_DIRS.has(name)) continue;
       if (ig.ignores(`${rel}/`)) continue;
@@ -1275,9 +1855,9 @@ async function walkDir(absDir, relDir, ig, out) {
   }
 }
 async function loadGitignoreInto(ig, absDir) {
-  const file = path3.join(absDir, ".gitignore");
+  const file = path4.join(absDir, ".gitignore");
   try {
-    const text = await readFile3(file, "utf8");
+    const text = await readFile4(file, "utf8");
     ig.add(text);
   } catch {
   }
@@ -1307,7 +1887,7 @@ async function indexRepo(opts) {
   await runWithConcurrency(parsable, parallelism, async (entry) => {
     const abs = join2(opts.repoPath, entry.rel);
     try {
-      const source = await readFile4(abs, "utf8");
+      const source = await readFile5(abs, "utf8");
       const result = await extractFile({
         repoId: opts.repoId,
         relativePath: entry.rel,
@@ -1324,11 +1904,13 @@ async function indexRepo(opts) {
       opts.onProgress?.({ type: "parse", parsed: parsedCount, total: parsable.length });
     }
   });
+  const tsconfigPaths = await loadTsconfigPaths(opts.repoPath);
   const { resolved, dropped } = resolveEdges({
     repoId: opts.repoId,
     nodes: allNodes,
     edges: allEdges,
-    knownFilePaths
+    knownFilePaths,
+    ...tsconfigPaths ? { tsconfigPaths } : {}
   });
   let embeddedById = /* @__PURE__ */ new Map();
   if (!opts.skipEmbeddings && opts.router) {
@@ -1376,11 +1958,11 @@ async function runWithConcurrency(items, concurrency, fn) {
 import kleur4 from "kleur";
 
 // src/repo-id.ts
-import { createHash as createHash3 } from "crypto";
-import path4 from "path";
+import { createHash as createHash4 } from "crypto";
+import path5 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 base = path5.basename(path5.resolve(absPath));
+  const sha = createHash4("sha1").update(path5.resolve(absPath)).digest("hex").slice(0, 8);
   const safe = base.replace(/[^A-Za-z0-9_-]/g, "_");
   return `${safe}-${sha}`;
 }
@@ -1388,7 +1970,7 @@ function repoIdFromPath(absPath) {
 // src/commands/index.ts
 async function runIndexCommand(opts) {
   const config = await loadConfig();
-  const absolutePath = path5.resolve(opts.repoPath);
+  const absolutePath = path6.resolve(opts.repoPath);
   const repoId = repoIdFromPath(absolutePath);
   const dbPath = config.data.dbPath ?? defaultDbPath();
   console.log(kleur4.dim(`repo:    ${absolutePath}`));
@@ -1426,8 +2008,10 @@ async function runIndexCommand(opts) {
       router = void 0;
     }
   }
-  let parseBar = null;
-  let embedBar = null;
+  const bars = {
+    parse: null,
+    embed: null
+  };
   const result = await indexRepo({
     repoId,
     repoPath: absolutePath,
@@ -1439,8 +2023,8 @@ async function runIndexCommand(opts) {
         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 (!bars.parse) bars.parse = new ProgressBar("parsing", event.total);
+        bars.parse.update(event.parsed);
       }
       if (event.type === "upsert") {
         console.log(
@@ -1448,13 +2032,13 @@ async function runIndexCommand(opts) {
         );
       }
       if (event.type === "embed") {
-        if (!embedBar) embedBar = new ProgressBar("embedding", event.total);
-        embedBar.update(event.embedded);
+        if (!bars.embed) bars.embed = new ProgressBar("embedding", event.total);
+        bars.embed.update(event.embedded);
       }
     }
   });
-  parseBar?.done();
-  embedBar?.done();
+  bars.parse?.done();
+  bars.embed?.done();
   await graphDb.close();
   console.log();
   console.log(
@@ -1470,7 +2054,7 @@ async function runIndexCommand(opts) {
 }
 async function runStatusCommand(opts) {
   const config = await loadConfig();
-  const absolutePath = path5.resolve(opts.repoPath);
+  const absolutePath = path6.resolve(opts.repoPath);
   const repoId = repoIdFromPath(absolutePath);
   const graphDb = new GraphDb({
     dbPath: config.data.dbPath ?? defaultDbPath(),
@@ -1488,16 +2072,71 @@ async function runStatusCommand(opts) {
     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";
+async function runWipeCommand(opts) {
+  const config = await loadConfig();
+  const dbPath = config.data.dbPath ?? defaultDbPath();
+  if (opts.repoPath) {
+    const absolutePath = path6.resolve(opts.repoPath);
+    const repoId = repoIdFromPath(absolutePath);
+    if (!opts.yes) {
+      console.log(
+        kleur4.yellow(
+          `Will delete all graph rows for ${kleur4.bold(repoId)} (${absolutePath}). Pass --yes to confirm.`
+        )
+      );
+      return;
+    }
+    const spinner2 = makeSpinner(`Wiping ${repoId}`).start();
+    const graphDb = new GraphDb({
+      dbPath,
+      embeddingDimension: config.llm.embeddings.dimension
+    });
+    try {
+      await graphDb.connect();
+      await graphDb.migrate();
+      await graphDb.deleteByRepo(repoId);
+      await graphDb.close();
+      spinner2.succeed(`Removed ${repoId} from ${dbPath}`);
+    } catch (err) {
+      spinner2.fail("Wipe failed");
+      throw err;
+    }
+    return;
+  }
+  if (!opts.yes) {
+    console.log(
+      kleur4.yellow(
+        `Will delete the entire graph directory at ${kleur4.bold(dbPath)}. Pass --yes to confirm.`
+      )
+    );
+    return;
+  }
+  const spinner = makeSpinner(`Removing ${dbPath}`).start();
+  try {
+    await rm(dbPath, { recursive: true, force: true });
+    spinner.succeed(`Graph directory removed. Re-run \`codegraph index <repo>\` to rebuild.`);
+  } catch (err) {
+    spinner.fail("Wipe failed");
+    throw err;
+  }
+}
+
+// src/commands/init.ts
+import { spawn } from "child_process";
+import path7 from "path";
+import { fileURLToPath } from "url";
+import { confirm, input as input2, password as password2, select as select2 } from "@inquirer/prompts";
+
+// ../mcp-server/dist/index.js
+import { createHash as createHash5 } from "crypto";
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+import { homedir } from "os";
+import { dirname as dirname3, resolve } from "path";
+import { randomUUID } from "crypto";
+import { join as join3 } from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import express, { Router } from "express";
 import { z } from "zod";
 import { z as z2 } from "zod";
 import { z as z3 } from "zod";
@@ -1510,7 +2149,7 @@ 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");
+  const hash = createHash5("sha1").update(serialized).digest("hex");
   return `codegraph:${namespace}:tool:${toolName}:${hash}`;
 }
 function stableStringify(value) {
@@ -1587,8 +2226,8 @@ var affectedByTool = {
     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";
+  handler: async ({ symbol, path: path8, depth, limit }, deps) => cachedJsonResult("affected_by", { symbol, path: path8, depth, limit }, deps, async () => {
+    const where = path8 ? "WHERE target.name = $symbol AND target.path = $path" : "WHERE target.name = $symbol";
     const rows = await deps.graph.query(
       `MATCH (target:Symbol) ${where}
          WITH target
@@ -1597,9 +2236,9 @@ var affectedByTool = {
          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 }
+      { symbol, path: path8 ?? null, limit }
     );
-    return { symbol, path: path6 ?? null, depth, count: rows.length, affected: rows };
+    return { symbol, path: path8 ?? null, depth, count: rows.length, affected: rows };
   })
 };
 var inputSchema2 = {
@@ -1616,14 +2255,14 @@ var blastRadiusTool = {
     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";
+  handler: async ({ symbol, path: path8, depth, sampleSize }, deps) => cachedJsonResult("blast_radius", { symbol, path: path8, depth, sampleSize }, deps, async () => {
+    const where = path8 ? "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 }
+      { symbol, path: path8 ?? null }
     );
     const sample = await deps.graph.query(
       `MATCH (target:Symbol) ${where}
@@ -1633,11 +2272,11 @@ var blastRadiusTool = {
            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 }
+      { symbol, path: path8 ?? null, sampleSize }
     );
     return {
       symbol,
-      path: path6 ?? null,
+      path: path8 ?? null,
       depth,
       totalDependents: stats?.total ?? 0,
       sample
@@ -1704,15 +2343,46 @@ var getComponentTreeTool = {
     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`,
+    const rootRows = await deps.graph.query(
+      `MATCH (root:Symbol)
+         WHERE root.name = $name AND (root.kind = 'Component' OR root.kind = 'Function' OR root.kind = 'Class')
+         RETURN root.id AS rootId, root.name AS rootName, root.path AS rootPath, root.kind AS rootKind
+         ORDER BY CASE root.kind WHEN 'Component' THEN 0 WHEN 'Function' THEN 1 ELSE 2 END
+         LIMIT 1`,
       { name }
     );
-    return { name, depth, tree: rows[0] ?? null };
+    const root = rootRows[0];
+    if (!root) {
+      return {
+        name,
+        depth,
+        found: false,
+        root: null,
+        children: []
+      };
+    }
+    const children = await deps.graph.query(
+      `MATCH (root:Symbol {id: $rootId})
+         OPTIONAL MATCH p = (root)-[:RENDERS*1..${depth}]->(child:Symbol)
+         WITH child, min(length(p)) AS distance
+         WHERE child IS NOT NULL
+         RETURN child.id AS id, child.name AS name, child.kind AS kind,
+                child.path AS path, distance
+         ORDER BY distance ASC, child.name ASC`,
+      { rootId: root.rootId }
+    );
+    return {
+      name,
+      depth,
+      found: true,
+      root: {
+        id: root.rootId,
+        name: root.rootName,
+        path: root.rootPath,
+        kind: root.rootKind
+      },
+      children
+    };
   })
 };
 var inputSchema6 = {
@@ -1728,7 +2398,7 @@ var getDependenciesTool = {
     inputSchema: inputSchema6,
     annotations: { readOnlyHint: true, idempotentHint: true }
   },
-  handler: async ({ path: path6, depth, limit }, deps) => cachedJsonResult("get_dependencies", { path: path6, depth, limit }, deps, async () => {
+  handler: async ({ path: path8, depth, limit }, deps) => cachedJsonResult("get_dependencies", { path: path8, depth, limit }, deps, async () => {
     const rows = await deps.graph.query(
       `MATCH (root:Symbol)
          WHERE root.kind = 'File' AND root.path = $path
@@ -1738,9 +2408,9 @@ var getDependenciesTool = {
          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 }
+      { path: path8, limit }
     );
-    return { path: path6, depth, count: rows.length, dependencies: rows };
+    return { path: path8, depth, count: rows.length, dependencies: rows };
   })
 };
 var inputSchema7 = {
@@ -1755,15 +2425,15 @@ var getFileContextTool = {
     inputSchema: inputSchema7,
     annotations: { readOnlyHint: true, idempotentHint: true }
   },
-  handler: async ({ path: path6, symbolLimit }, deps) => cachedJsonResult("get_file_context", { path: path6, symbolLimit }, deps, async () => {
+  handler: async ({ path: path8, symbolLimit }, deps) => cachedJsonResult("get_file_context", { path: path8, 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 }
+      { path: path8 }
     );
     if (fileRows.length === 0) {
-      return { path: path6, found: false };
+      return { path: path8, found: false };
     }
     const [defined, imports, exports, importers] = await Promise.all([
       deps.graph.query(
@@ -1771,30 +2441,33 @@ var getFileContextTool = {
            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 }
+        { path: path8, limit: symbolLimit }
       ),
       deps.graph.query(
+        // Kuzu drops the node variable `t` from scope after `RETURN DISTINCT`, so the
+        // ORDER BY references the projection alias instead - using `t.path` here
+        // raises a "Variable t is not in scope" binder exception.
         `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 }
+           RETURN DISTINCT t.path AS path ORDER BY path`,
+        { path: path8 }
       ),
       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 }
+        { path: path8 }
       ),
       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 DISTINCT other.path AS path ORDER BY path`,
+        { path: path8 }
       )
     ]);
     return {
-      path: path6,
+      path: path8,
       found: true,
       file: fileRows[0],
       definedSymbols: defined,
@@ -1839,11 +2512,11 @@ function findForbiddenKeyword(upper) {
   }
   return null;
 }
-function validateReadOnlyCypher(input) {
-  if (typeof input !== "string" || input.trim().length === 0) {
+function validateReadOnlyCypher(input3) {
+  if (typeof input3 !== "string" || input3.trim().length === 0) {
     return { ok: false, reason: "Empty Cypher statement." };
   }
-  const withoutComments = stripComments(input);
+  const withoutComments = stripComments(input3);
   const sanitized = stripStringLiterals(withoutComments).trim();
   const withoutTrailingSemicolon = sanitized.replace(/;\s*$/, "");
   if (withoutTrailingSemicolon.includes(";")) {
@@ -2073,6 +2746,63 @@ function registerAllTools(server, deps) {
     });
   }
 }
+function registerViewerApiRoutes(router, graph) {
+  router.get("/api/repos", async (_req, res) => {
+    try {
+      const rows = await graph.query(
+        "MATCH (n:Symbol) RETURN DISTINCT n.repoId AS repoId ORDER BY repoId"
+      );
+      const repos = rows.map((r) => r.repoId).filter((id) => typeof id === "string" && id.length > 0);
+      res.json({ repos });
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+  router.get("/api/graph", async (req, res) => {
+    const repoId = req.query.repoId;
+    if (!repoId) {
+      res.status(400).json({ error: "Missing repoId query parameter" });
+      return;
+    }
+    const limit = Math.min(Number(req.query.limit) || 600, 2e3);
+    try {
+      const nodeRows = await graph.query(
+        `MATCH (n:Symbol)
+         WHERE n.repoId = $repoId
+         RETURN n.id AS id, n.kind AS kind, n.name AS name,
+                n.path AS path, n.lineStart AS lineStart
+         ORDER BY n.path ASC, n.lineStart ASC
+         LIMIT $limit`,
+        { repoId, limit }
+      );
+      const nodeIds = new Set(
+        nodeRows.map((n) => n.id).filter((v) => typeof v === "string")
+      );
+      const edgeRows = [];
+      const edgeLimit = limit * 3;
+      for (const kind of EDGE_KINDS) {
+        const rows = await graph.query(
+          `MATCH (a:Symbol)-[:${kind}]->(b:Symbol)
+           WHERE a.repoId = $repoId AND b.repoId = $repoId
+           RETURN a.id AS fromId, b.id AS toId
+           LIMIT $edgeLimit`,
+          { repoId, edgeLimit }
+        );
+        for (const r of rows) {
+          const from = r.fromId;
+          const to = r.toId;
+          if (typeof from !== "string" || typeof to !== "string") continue;
+          if (!nodeIds.has(from) || !nodeIds.has(to)) continue;
+          edgeRows.push({ from, to, kind });
+        }
+      }
+      res.json({ repoId, nodes: nodeRows, edges: edgeRows });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      res.status(500).json({ error: message });
+    }
+  });
+}
 function createMcpServer(opts) {
   const info = opts.serverInfo ?? { name: "codegraph", version: "0.0.0" };
   const server = new McpServer(info, {
@@ -2089,6 +2819,23 @@ async function startSseServer(opts) {
   app.get("/healthz", (_req, res) => {
     res.status(200).json({ ok: true });
   });
+  if (opts.viewerDir) {
+    const viewerDir = opts.viewerDir;
+    const sendIndex = (_req, res, next) => {
+      res.sendFile(join3(viewerDir, "index.html"), (err) => {
+        if (err) next(err);
+      });
+    };
+    app.get("/viewer", sendIndex);
+    app.get("/viewer/", sendIndex);
+    app.use(
+      "/viewer",
+      express.static(viewerDir, { index: false, fallthrough: false })
+    );
+    const apiRouter = Router();
+    registerViewerApiRoutes(apiRouter, deps.graph);
+    app.use(apiRouter);
+  }
   app.use(bearerAuthMiddleware(config.bearerToken, logger));
   const transports = /* @__PURE__ */ new Map();
   app.get("/mcp", async (_req, res) => {
@@ -2208,23 +2955,23 @@ var DEFAULT_TTL = 30;
 function defaultConfigPath() {
   return resolve(homedir(), ".codegraph", "config.json");
 }
-async function readCodegraphConfig(path6 = defaultConfigPath()) {
+async function readCodegraphConfig(path8 = defaultConfigPath()) {
   try {
-    const raw = await readFile5(path6, "utf8");
+    const raw = await readFile6(path8, "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)}
+async function writeCodegraphConfig(config, path8 = defaultConfigPath()) {
+  await mkdir3(dirname3(path8), { recursive: true });
+  await writeFile2(path8, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 async function resolveServerConfig(opts) {
-  const path6 = opts.configPath ?? defaultConfigPath();
-  const fileConfig = await readCodegraphConfig(path6);
+  const path8 = opts.configPath ?? defaultConfigPath();
+  const fileConfig = await readCodegraphConfig(path8);
   const env = process.env;
   let bearerToken = opts.overrides?.bearerToken ?? fileConfig.mcpToken ?? fileConfig.server?.bearerToken ?? env.CODEGRAPH_BEARER_TOKEN ?? "";
   let created = false;
@@ -2237,7 +2984,7 @@ async function resolveServerConfig(opts) {
         mcpToken: bearerToken,
         server: { ...fileConfig.server ?? {}, bearerToken }
       },
-      path6
+      path8
     );
   }
   const config = {
@@ -2246,7 +2993,7 @@ async function resolveServerConfig(opts) {
     bearerToken,
     cacheTtlSeconds: opts.overrides?.cacheTtlSeconds ?? fileConfig.server?.cacheTtlSeconds ?? (env.CODEGRAPH_CACHE_TTL ? Number(env.CODEGRAPH_CACHE_TTL) : DEFAULT_TTL)
   };
-  return { config, configPath: path6, created };
+  return { config, configPath: path8, created };
 }
 function resolveDbPath(fileConfig) {
   return fileConfig.data?.dbPath ?? process.env.CODEGRAPH_DB_PATH ?? void 0;
@@ -2289,12 +3036,12 @@ async function startMcpServer(portOrOptions) {
     cacheTtlSeconds: config.cacheTtlSeconds,
     logger
   };
-  return startSseServer({ deps, config });
+  return startSseServer({ deps, config, viewerDir: options.viewerDir });
 }
 async function loadGraphClient(dbPath) {
   let mod;
   try {
-    mod = await import("./src-PDNTANJD.js");
+    mod = await import("./src-BTVJBGZ5.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)}`
@@ -2320,7 +3067,7 @@ async function loadGraphClient(dbPath) {
 async function loadLlmRouter(configPath2) {
   let mod;
   try {
-    mod = await import("./src-UVET6JHH.js");
+    mod = await import("./src-DBJQ22XR.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)}`
@@ -2352,24 +3099,682 @@ function adaptLlmRouter(router) {
   };
 }
 
+// src/commands/init.ts
+import boxen2 from "boxen";
+import kleur5 from "kleur";
+var TOTAL_STEPS = 6;
+async function runInitCommand() {
+  printWelcome();
+  const start = await confirm({ message: "Ready to get started?", default: true });
+  if (!start) {
+    console.log(kleur5.dim("Aborted. Run `codegraph init` again any time."));
+    return;
+  }
+  runEnvCheck();
+  await runLlmSetup();
+  await runLiveTest();
+  await runIndexStep();
+  const bearerToken = await runServeStep();
+  await runClientStep(bearerToken);
+  await runCelebration();
+}
+function printWelcome() {
+  printBanner();
+  const description = [
+    kleur5.bold("CodeGraph") + " parses your JS/TS repo with tree-sitter, stores nodes (Function, Class,",
+    "Route\u2026) and edges (CALLS, IMPORTS, RENDERS\u2026) in an embedded Kuzu graph with",
+    "vector embeddings, then runs a local MCP server your AI assistant can call.",
+    "",
+    kleur5.dim("This wizard will:"),
+    `  ${kleur5.cyan("1.")} Configure an LLM provider (cloud or local)`,
+    `  ${kleur5.cyan("2.")} Verify your credentials with a live round-trip`,
+    `  ${kleur5.cyan("3.")} Index this repo into the graph`,
+    `  ${kleur5.cyan("4.")} Show you how to boot the MCP server`,
+    `  ${kleur5.cyan("5.")} Print a copy-paste config for your AI client`
+  ].join("\n");
+  process.stdout.write(
+    `${boxen2(description, {
+      padding: 1,
+      margin: { top: 0, bottom: 1, left: 0, right: 0 },
+      borderStyle: "round",
+      borderColor: "cyan",
+      title: kleur5.bold("Welcome"),
+      titleAlignment: "left"
+    })}
+`
+  );
+}
+function stepHeader(n, label) {
+  console.log();
+  console.log(
+    kleur5.cyan(`\u2500\u2500\u2500\u2500 Step ${n}/${TOTAL_STEPS}: ${kleur5.bold(label)} ${"\u2500".repeat(Math.max(4, 40 - label.length))}`)
+  );
+}
+function runEnvCheck() {
+  stepHeader(1, "Environment check");
+  const version = process.versions.node;
+  const major = Number(version.split(".")[0] ?? 0);
+  if (major < 20) {
+    console.log(`${kleur5.red("\u2717")}  node version  v${version} ${kleur5.red("(codegraph requires >= 20)")}`);
+    throw new Error(`Node ${version} is too old; install Node 20+ and re-run \`codegraph init\`.`);
+  }
+  console.log(`${kleur5.green("\u2713")}  node version  ${kleur5.dim(`v${version}`)}`);
+}
+async function runLlmSetup() {
+  stepHeader(2, "LLM setup");
+  const mode = await select2({
+    message: "How would you like to power CodeGraph?",
+    choices: [
+      {
+        name: "Local, zero cost",
+        value: "local",
+        description: "Runs entirely on your laptop. No API keys. Uses Ollama (guided install)."
+      },
+      {
+        name: "Cloud provider",
+        value: "cloud",
+        description: "OpenAI, Anthropic, or Google. Better quality, requires an API key."
+      }
+    ]
+  });
+  if (mode === "local") {
+    await setupLocalOllama();
+  } else {
+    await setupCloudProvider();
+  }
+}
+async function setupLocalOllama() {
+  const spinner = makeSpinner("Detecting Ollama").start();
+  let detection = await detectOllama();
+  spinner.stop();
+  if (detection.status === "not-installed") {
+    console.log();
+    console.log(kleur5.yellow("  Ollama is not installed."));
+    console.log(`  ${kleur5.cyan("\u2192")} Install from: ${kleur5.underline("https://ollama.com")}`);
+    console.log(`  ${kleur5.dim("  Then run: ollama serve")}`);
+    openUrl("https://ollama.com");
+    const next = await select2({
+      message: "What would you like to do?",
+      choices: [
+        { name: "I just installed it \u2014 detect again", value: "retry" },
+        { name: "Use a custom local server (llama.cpp, LM Studio, vLLM\u2026)", value: "custom" },
+        { name: "Switch to a cloud provider instead", value: "cloud" },
+        { name: "Skip for now (configure LLM later)", value: "skip" }
+      ]
+    });
+    if (next === "retry") {
+      await setupLocalOllama();
+      return;
+    }
+    if (next === "custom") {
+      await setupCustomUrl();
+      return;
+    }
+    if (next === "cloud") {
+      await setupCloudProvider();
+      return;
+    }
+    console.log(kleur5.yellow("! Skipped. Run `codegraph config llm set` to configure later."));
+    return;
+  }
+  if (detection.status === "installed-not-running") {
+    console.log();
+    console.log(kleur5.yellow("  Ollama is installed but not running."));
+    console.log(`  Start it in another terminal: ${kleur5.cyan("ollama serve")}`);
+    while (true) {
+      const next = await select2({
+        message: "What would you like to do?",
+        choices: [
+          { name: "Retry (I started ollama serve)", value: "retry" },
+          { name: "Use a custom local server (llama.cpp, LM Studio, vLLM\u2026)", value: "custom" },
+          { name: "Switch to a cloud provider instead", value: "cloud" },
+          { name: "Skip for now (configure LLM later)", value: "skip" }
+        ]
+      });
+      if (next === "custom") {
+        await setupCustomUrl();
+        return;
+      }
+      if (next === "cloud") {
+        await setupCloudProvider();
+        return;
+      }
+      if (next === "skip") {
+        console.log(kleur5.yellow("! Skipped. Run `codegraph config llm set` to configure later."));
+        return;
+      }
+      const retrySpinner = makeSpinner("Checking Ollama").start();
+      detection = await detectOllama();
+      retrySpinner.stop();
+      if (detection.status === "ready" || detection.status === "running-no-models") break;
+      console.log(kleur5.red("  \u2717  Ollama still not reachable on :11434."));
+    }
+  }
+  if (detection.status === "running-no-models") {
+    console.log(kleur5.dim(`  Ollama is running. Pulling required models\u2026`));
+    try {
+      await pullOllamaModels();
+    } catch (err) {
+      console.log(
+        kleur5.yellow(`! Pull failed: ${err instanceof Error ? err.message : String(err)}`)
+      );
+      console.log(kleur5.dim("  You can pull manually: ollama pull qwen2.5-coder:1.5b && ollama pull nomic-embed-text"));
+    }
+  }
+  if (detection.status === "ready") {
+    console.log(`${kleur5.green("\u2713")}  Ollama ready, required models present`);
+  }
+  const config = await loadConfig();
+  const lookup = LLM_PRESETS["local-ollama"];
+  config.llm = { ...config.llm, ...lookup };
+  config.llm.baseUrl = void 0;
+  await saveConfig(config);
+  console.log(`${kleur5.green("\u2713")}  preset saved   ${kleur5.dim('"local-ollama" \u2192 ' + configPath())}`);
+  console.log(`${kleur5.dim("   namespace     ")}${namespaceLabel(config.llm)}`);
+}
+async function pullOllamaModels() {
+  for (const model of [LOCAL_MODELS.generation, LOCAL_MODELS.embeddings]) {
+    console.log(kleur5.dim(`  pulling ${model}\u2026`));
+    await new Promise((resolve2, reject) => {
+      const child = spawn("ollama", ["pull", model], { stdio: "inherit" });
+      child.on(
+        "error",
+        (err) => reject(new Error(`Failed to spawn ollama: ${err.message}`))
+      );
+      child.on("exit", (code) => {
+        if (code === 0) resolve2();
+        else reject(new Error(`ollama pull ${model} exited with code ${code}`));
+      });
+    });
+  }
+  console.log(`${kleur5.green("\u2713")}  models ready`);
+}
+async function setupCustomUrl() {
+  console.log();
+  console.log(kleur5.dim("  Compatible servers: llama.cpp server, LM Studio, vLLM, LocalAI"));
+  console.log(kleur5.dim("  Make sure your server exposes /v1/chat/completions and /v1/embeddings"));
+  console.log();
+  const baseUrl = await input2({
+    message: "Server base URL:",
+    default: "http://localhost:8080/v1",
+    validate: (v) => v.trim().startsWith("http") ? true : "Must be an http(s) URL"
+  });
+  const genModel = await input2({
+    message: "Generation model name (as loaded in your server):",
+    default: "qwen2.5-coder"
+  });
+  const embedModel = await input2({
+    message: "Embedding model name:",
+    default: "nomic-embed-text"
+  });
+  const lookup = LLM_PRESETS["local-openai-compatible"];
+  const config = await loadConfig();
+  config.llm = {
+    ...config.llm,
+    ...lookup,
+    generation: { provider: "openai", model: genModel.trim() },
+    embeddings: { provider: "openai", model: embedModel.trim(), dimension: 768 },
+    baseUrl: baseUrl.trim()
+  };
+  await saveConfig(config);
+  console.log();
+  console.log(
+    `${kleur5.green("\u2713")}  preset saved   ${kleur5.dim('"local-openai-compatible" \u2192 ' + configPath())}`
+  );
+  console.log(`${kleur5.dim("   base URL      ")}${kleur5.dim(baseUrl.trim())}`);
+  console.log(
+    kleur5.dim(
+      "  Tip: edit ~/.codegraph/config.json to adjust embeddings.dimension if your model differs from 768."
+    )
+  );
+}
+async function setupCloudProvider() {
+  const preset = await select2({
+    message: "Which cloud provider?",
+    choices: [
+      {
+        name: "OpenAI",
+        value: "byo-openai",
+        description: "gpt-4o-mini + text-embedding-3-small"
+      },
+      {
+        name: "Anthropic",
+        value: "byo-anthropic",
+        description: "claude-3-5-haiku (gen) + OpenAI text-embedding-3-small (embed)"
+      },
+      {
+        name: "Google",
+        value: "byo-google",
+        description: "gemini-1.5-flash + text-embedding-004"
+      }
+    ]
+  });
+  const lookup = LLM_PRESETS[preset];
+  if (!lookup) throw new Error(`Unknown preset "${preset}".`);
+  const config = await loadConfig();
+  config.llm = { ...config.llm, ...lookup };
+  config.llm.baseUrl = void 0;
+  await saveConfig(config);
+  console.log();
+  console.log(`${kleur5.green("\u2713")}  preset saved   ${kleur5.dim(`"${preset}" \u2192 ${configPath()}`)}`);
+  console.log(`${kleur5.dim("   namespace     ")}${namespaceLabel(config.llm)}`);
+  if (preset === "byo-anthropic") {
+    console.log();
+    console.log(kleur5.yellow("Note: Anthropic has no embedding API, so codegraph uses OpenAI embeddings."));
+    console.log(kleur5.yellow("You'll need both ANTHROPIC_API_KEY and OPENAI_API_KEY set."));
+    await promptApiKey("ANTHROPIC_API_KEY");
+    await promptApiKey("OPENAI_API_KEY");
+    return;
+  }
+  const envVar = apiKeyEnvVarFor2(preset);
+  if (envVar) await promptApiKey(envVar);
+}
+function openUrl(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  const child = spawn(cmd, [url], { detached: true, stdio: "ignore" });
+  child.unref();
+}
+function apiKeyEnvVarFor2(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;
+}
+async function promptApiKey(envVar) {
+  console.log();
+  if (process.env[envVar]) {
+    console.log(`${kleur5.green("\u2713")}  ${envVar} ${kleur5.dim("already set in this shell")}`);
+    return;
+  }
+  const provide = await confirm({
+    message: `${envVar} is not set. Provide it now? (input will be hidden)`,
+    default: true
+  });
+  if (!provide) {
+    console.log(
+      kleur5.yellow(`! Skipped. Export ${envVar} before \`codegraph index\` or \`codegraph serve\`.`)
+    );
+    return;
+  }
+  const value = await password2({ message: `${envVar}`, mask: "*" });
+  if (!value) {
+    console.log(kleur5.yellow(`! Empty value \u2014 skipping ${envVar}.`));
+    return;
+  }
+  process.env[envVar] = value;
+  console.log();
+  console.log(kleur5.dim("Add this to your ~/.zshrc or ~/.bashrc so it persists:"));
+  console.log(`  ${kleur5.cyan(`export ${envVar}=${maskTail(value)}`)}`);
+}
+function maskTail(value) {
+  if (value.length <= 8) return "*".repeat(value.length);
+  return `${"*".repeat(value.length - 4)}${value.slice(-4)}`;
+}
+async function runLiveTest() {
+  stepHeader(3, "Verify credentials");
+  while (true) {
+    const config = await loadConfig();
+    console.log(
+      kleur5.dim(
+        `  testing ${config.llm.generation.provider}:${config.llm.generation.model} + ${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(
+        kleur5.dim(
+          `   embed=${result.embedLatencyMs}ms gen=${result.generateLatencyMs}ms dims=${result.embedDims}`
+        )
+      );
+      return;
+    } catch (err) {
+      spinner.fail("LLM provider unreachable");
+      console.log(kleur5.red(`   ${err instanceof Error ? err.message : String(err)}`));
+      const choice = await select2({
+        message: "What now?",
+        choices: [
+          { name: "Retry (I'll fix it in another terminal)", value: "retry" },
+          { name: "Skip \u2014 set up LLM later", value: "skip" }
+        ]
+      });
+      if (choice === "skip") {
+        console.log(
+          kleur5.yellow(
+            "! Continuing without a verified LLM. Embeddings and semantic search will fail until you fix this."
+          )
+        );
+        return;
+      }
+    }
+  }
+}
+async function runIndexStep() {
+  stepHeader(4, "Index this repo");
+  const cwd = process.cwd();
+  const display = abbreviateHome(cwd);
+  const yes = await confirm({
+    message: `Index the current directory (${display}) now?`,
+    default: true
+  });
+  if (!yes) {
+    console.log(kleur5.dim("Skipped. Run this when ready:"));
+    console.log(`  ${kleur5.cyan(`codegraph index ${display}`)}`);
+    return;
+  }
+  console.log();
+  const binPath = resolveBinPath();
+  try {
+    await spawnIndex(binPath, cwd);
+  } catch (err) {
+    console.log();
+    console.log(
+      kleur5.yellow(
+        `! Index failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    console.log(
+      kleur5.dim("   You can retry later with `codegraph index <path>`. Continuing wizard.")
+    );
+  }
+}
+function resolveBinPath() {
+  if (process.argv[1] && path7.isAbsolute(process.argv[1])) return process.argv[1];
+  return fileURLToPath(new URL("./bin.js", import.meta.url));
+}
+function spawnIndex(binPath, repoPath) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(process.execPath, [binPath, "index", repoPath], {
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`codegraph index terminated by signal ${signal}`));
+        return;
+      }
+      if (code !== 0) {
+        reject(new Error(`codegraph index exited with code ${code}`));
+        return;
+      }
+      resolvePromise();
+    });
+  });
+}
+async function runServeStep() {
+  stepHeader(5, "Boot the MCP server");
+  const { config: serverConfig, created } = await resolveServerConfig({});
+  if (created) {
+    console.log(kleur5.dim("  generated a new bearer token for this machine"));
+  }
+  const url = `http://${serverConfig.host}:${serverConfig.port}/mcp`;
+  const body = [
+    "Open a " + kleur5.bold("new terminal") + " and run:",
+    "",
+    `    ${kleur5.cyan("codegraph serve")}`,
+    "",
+    kleur5.dim("Expected output:"),
+    kleur5.dim(`    codegraph mcp listening on ${url}`),
+    "",
+    kleur5.dim("Keep that terminal running while you use CodeGraph.")
+  ].join("\n");
+  process.stdout.write(
+    `${boxen2(body, {
+      padding: { top: 0, bottom: 0, left: 2, right: 2 },
+      margin: { top: 1, bottom: 1, left: 0, right: 0 },
+      borderStyle: "round",
+      borderColor: "cyan",
+      title: kleur5.bold("Start the server"),
+      titleAlignment: "left"
+    })}
+`
+  );
+  await confirm({
+    message: "Done \u2014 the server is running in another terminal?",
+    default: true
+  });
+  return serverConfig.bearerToken;
+}
+async function runClientStep(bearerToken) {
+  stepHeader(6, "Connect your AI client");
+  const url = "http://127.0.0.1:3748/mcp";
+  const client = await select2({
+    message: "Which AI client are you connecting?",
+    choices: [
+      { name: "Cursor", value: "cursor" },
+      { name: "Claude Code", value: "claude" },
+      { name: "Windsurf", value: "windsurf" },
+      { name: "Skip for now", value: "skip" }
+    ]
+  });
+  if (client === "skip") {
+    console.log(
+      kleur5.dim("Skipped. See docs/clients.md for per-client configuration when ready.")
+    );
+    return;
+  }
+  if (client === "cursor") {
+    const snippet = JSON.stringify(
+      {
+        mcpServers: {
+          codegraph: {
+            url,
+            headers: { Authorization: `Bearer ${bearerToken}` }
+          }
+        }
+      },
+      null,
+      2
+    );
+    const body = [
+      "Create or edit " + kleur5.cyan(".cursor/mcp.json") + " in your project root:",
+      "",
+      kleur5.green(snippet),
+      "",
+      kleur5.dim("Then open Cursor \u2192 Settings \u2192 MCP."),
+      kleur5.dim("`codegraph` should appear as connected with 10 tools.")
+    ].join("\n");
+    process.stdout.write(
+      `${boxen2(body, {
+        padding: 1,
+        margin: { top: 1, bottom: 1, left: 0, right: 0 },
+        borderStyle: "round",
+        borderColor: "magenta",
+        title: kleur5.bold("Cursor config"),
+        titleAlignment: "left"
+      })}
+`
+    );
+  } else if (client === "claude") {
+    const oneliner = [
+      "claude mcp add --transport sse codegraph \\",
+      `  ${url} \\`,
+      `  --header "Authorization: Bearer ${bearerToken}"`
+    ].join("\n");
+    const body = [
+      "Run this in your terminal:",
+      "",
+      kleur5.green(oneliner),
+      "",
+      kleur5.dim("Then type ") + kleur5.cyan("/mcp") + kleur5.dim(" in Claude Code to confirm 10 tools are listed.")
+    ].join("\n");
+    process.stdout.write(
+      `${boxen2(body, {
+        padding: 1,
+        margin: { top: 1, bottom: 1, left: 0, right: 0 },
+        borderStyle: "round",
+        borderColor: "magenta",
+        title: kleur5.bold("Claude Code config"),
+        titleAlignment: "left"
+      })}
+`
+    );
+  } else {
+    const snippet = JSON.stringify(
+      {
+        mcpServers: {
+          codegraph: {
+            serverUrl: url,
+            headers: { Authorization: `Bearer ${bearerToken}` }
+          }
+        }
+      },
+      null,
+      2
+    );
+    const body = [
+      "Edit " + kleur5.cyan("~/.codeium/windsurf/mcp_config.json") + ":",
+      "",
+      kleur5.green(snippet),
+      "",
+      kleur5.dim("Then restart Windsurf or run ") + kleur5.cyan("/refresh-tools") + kleur5.dim(" in Cascade.")
+    ].join("\n");
+    process.stdout.write(
+      `${boxen2(body, {
+        padding: 1,
+        margin: { top: 1, bottom: 1, left: 0, right: 0 },
+        borderStyle: "round",
+        borderColor: "magenta",
+        title: kleur5.bold("Windsurf config"),
+        titleAlignment: "left"
+      })}
+`
+    );
+  }
+  await confirm({
+    message: "Done \u2014 your client is configured?",
+    default: true
+  });
+}
+async function runCelebration() {
+  console.log();
+  console.log(kleur5.cyan(`\u2500\u2500\u2500\u2500 ${kleur5.bold("Almost there!")} \u2500\u2500\u2500\u2500`));
+  console.log(
+    kleur5.dim(
+      'Ask your AI assistant something like: "What files are in this repo?"'
+    )
+  );
+  console.log(
+    kleur5.dim("It should call a `codegraph_*` MCP tool to answer.")
+  );
+  console.log();
+  const choice = await select2({
+    message: "How did it go?",
+    choices: [
+      { name: "It worked!", value: "worked" },
+      { name: "Skip", value: "skip" }
+    ]
+  });
+  const header = choice === "worked" ? kleur5.green().bold("\u2713  CodeGraph is fully connected!") : kleur5.cyan().bold("\u2713  CodeGraph setup complete");
+  const body = [
+    header,
+    "",
+    "Your AI assistant can now call these tools:",
+    `  ${kleur5.cyan("\u2022")} find_callers       \u2014 what calls a function`,
+    `  ${kleur5.cyan("\u2022")} get_component_tree \u2014 render dependency tree`,
+    `  ${kleur5.cyan("\u2022")} blast_radius       \u2014 impact of a change`,
+    `  ${kleur5.cyan("\u2022")} search_semantic    \u2014 symbol search by description`,
+    `  ${kleur5.cyan("\u2022")} nl_query           \u2014 natural-language Cypher`,
+    `  ${kleur5.dim("\u2026plus 5 more (search_symbol, find_file, get_file_context,")}`,
+    `  ${kleur5.dim("    get_dependencies, affected_by)")}`,
+    "",
+    kleur5.dim("Visualise the graph:"),
+    `  ${kleur5.cyan("codegraph view")}              ${kleur5.dim("\u2014 opens the interactive graph explorer in your browser")}`,
+    `  ${kleur5.dim("or visit")} ${kleur5.cyan("http://127.0.0.1:3748/viewer")} ${kleur5.dim("while the server is running")}`,
+    "",
+    kleur5.dim("Helpful next steps:"),
+    `  ${kleur5.cyan("codegraph doctor")}   ${kleur5.dim("\u2014 verify environment + LLM + Kuzu")}`,
+    `  ${kleur5.cyan("codegraph status")} ${kleur5.dim("<path>")}  ${kleur5.dim("\u2014 node/edge counts + embedding coverage")}`,
+    "",
+    kleur5.dim("Docs: https://github.com/leanlabsinnov/codegraph")
+  ].join("\n");
+  process.stdout.write(
+    `${boxen2(body, {
+      padding: 1,
+      margin: { top: 1, bottom: 1, left: 0, right: 0 },
+      borderStyle: "round",
+      borderColor: choice === "worked" ? "green" : "cyan"
+    })}
+`
+  );
+}
+function abbreviateHome(p) {
+  const home = process.env.HOME ?? process.env.USERPROFILE;
+  if (!home) return p;
+  const rel = path7.relative(home, p);
+  if (rel.startsWith("..")) return p;
+  return rel ? `~${path7.sep}${rel}` : "~";
+}
+
 // src/commands/serve.ts
+import { realpathSync } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import kleur6 from "kleur";
+function resolveViewerDir() {
+  try {
+    const here = fileURLToPath2(import.meta.url);
+    return join4(dirname4(here), "..", "viewer");
+  } catch {
+  }
+  try {
+    const bin = realpathSync(process.argv[1] ?? "");
+    return join4(dirname4(bin), "..", "viewer");
+  } catch {
+    return join4(dirname4(process.argv[1] ?? ""), "..", "viewer");
+  }
+}
+function providerEnvVar2(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 runServeCommand(opts = {}) {
+  try {
+    const config = await loadConfig();
+    const missing = [];
+    for (const provider of [
+      config.llm.generation.provider,
+      config.llm.embeddings.provider
+    ]) {
+      const envVar = providerEnvVar2(provider);
+      if (envVar && !process.env[envVar] && !missing.includes(envVar)) {
+        missing.push(envVar);
+      }
+    }
+    if (missing.length > 0) {
+      process.stderr.write(
+        `${kleur6.yellow(
+          `! ${missing.join(", ")} not set in serve's environment. Semantic search and nl_query will fail until the variable is exported before \`codegraph serve\`.`
+        )}
+`
+      );
+    }
+  } catch {
+  }
   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 } : {}
+      ...opts.dbPath !== void 0 ? { dbPath: opts.dbPath } : {},
+      viewerDir: resolveViewerDir()
     });
     spinner.stop();
   } catch (err) {
     spinner.fail("Server failed to start");
     throw err;
   }
-  const url = `http://${started.address.host}:${started.address.port}/mcp`;
+  const base = `http://${started.address.host}:${started.address.port}`;
+  const url = `${base}/mcp`;
+  const viewerUrl = `${base}/viewer`;
   const tokenHint = "bearer token at ~/.codegraph/config.json (codegraph config show to view)";
-  process.stdout.write(`${renderServeBanner(url, tokenHint)}
+  process.stdout.write(`${renderServeBanner(url, tokenHint, viewerUrl)}
 `);
   const shutdown = async (signal) => {
     process.stderr.write(`
@@ -2391,16 +3796,70 @@ shutting down (${signal})...
   });
 }
 
+// src/commands/view.ts
+import { exec } from "child_process";
+import kleur7 from "kleur";
+var DEFAULT_HOST2 = "127.0.0.1";
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, (err) => {
+    if (err) {
+      process.stderr.write(
+        `${kleur7.yellow("!")} Could not open browser automatically. Open manually:
+  ${kleur7.cyan(url)}
+`
+      );
+    }
+  });
+}
+async function isServerUp(host, port) {
+  try {
+    const res = await fetch(`http://${host}:${port}/healthz`, {
+      signal: AbortSignal.timeout(1500)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function runViewCommand(opts = {}) {
+  const host = opts.host ?? DEFAULT_HOST2;
+  const port = opts.port ?? MCP_PORT;
+  const viewerUrl = `http://${host}:${port}/viewer`;
+  process.stdout.write(kleur7.dim(`Checking server at http://${host}:${port}/healthz \u2026
+`));
+  const up = await isServerUp(host, port);
+  if (!up) {
+    process.stdout.write(
+      [
+        "",
+        `${kleur7.red("\u2717")} CodeGraph server is not running.`,
+        "",
+        `  Start it with:  ${kleur7.cyan("codegraph serve")}`,
+        `  Then re-run:    ${kleur7.cyan("codegraph view")}`,
+        ""
+      ].join("\n")
+    );
+    process.exit(1);
+  }
+  process.stdout.write(`${kleur7.green("\u2713")} Server is up. Opening ${kleur7.cyan(viewerUrl)} \u2026
+`);
+  openBrowser(viewerUrl);
+}
+
 // src/program.ts
 function buildProgram() {
   const program = new Command();
-  program.name("codegraph").description("Live, queryable knowledge graph for your codebase").version("0.1.2").option("--verbose", "Print full stack traces on error").hook("preAction", (thisCommand) => {
+  program.name("codegraph").description("Live, queryable knowledge graph for your codebase").version("0.1.3").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("init").description("Interactive setup wizard \u2014 LLM, credentials, index, MCP, client connect").action(async () => {
+    await runInitCommand();
+  });
   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 });
   });
@@ -2414,9 +3873,21 @@ function buildProgram() {
       ...opts.dbPath !== void 0 ? { dbPath: opts.dbPath } : {}
     });
   });
+  program.command("view").description("Open the graph viewer in the browser (requires codegraph serve to be running)").option("--port <port>", "MCP server port to check (default 3748)", (v) => Number(v)).option("--host <host>", "MCP server host (default 127.0.0.1)").action(async (opts) => {
+    await runViewCommand({
+      ...opts.port !== void 0 ? { port: opts.port } : {},
+      ...opts.host !== void 0 ? { host: opts.host } : {}
+    });
+  });
   program.command("doctor").description("Check environment, config, LLM credentials, and Kuzu DB health").action(async () => {
     await runDoctorCommand();
   });
+  program.command("wipe").description("Delete a single repo's slice (with [path]) or the entire on-disk graph").argument("[path]", "Repo path. Omit to wipe the whole graph directory.").option("--yes", "Skip the confirmation prompt", false).action(async (repoPath, opts) => {
+    await runWipeCommand({
+      ...repoPath ? { repoPath } : {},
+      yes: opts.yes === true
+    });
+  });
   const configCmd = program.command("config").description("Manage ~/.codegraph/config.json");
   configCmd.command("show").description("Print the resolved config").action(async () => {
     await runConfigShow();
@@ -2440,4 +3911,4 @@ export {
   renderError,
   buildProgram
 };
-//# sourceMappingURL=chunk-36AWRLQ6.js.map
+//# sourceMappingURL=chunk-64OLVRK3.js.map