@leanlabsinnov/codegraph 0.1.3 → 0.1.5

package/dist/{chunk-5WYXRWEY.js → chunk-KYPDPBI5.js}

@@ -1,17 +1,18 @@
 import {
   createLlmRouter,
   namespaceLabel
-} from "./chunk-B2TIVKUB.js";
+} from "./chunk-GOJIV25M.js";
 import {
   GraphDb,
   defaultDbPath
-} from "./chunk-AVP24SX5.js";
+} from "./chunk-C2AULDUQ.js";
 import {
   DEFAULT_CONFIG,
+  EDGE_KINDS,
   LLM_PRESETS,
   makeFileId,
   makeNodeId
-} from "./chunk-XGPZDCQ4.js";
+} from "./chunk-Z6DQLXRR.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));
@@ -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 });
@@ -471,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();
@@ -510,6 +602,8 @@ function detectLanguage(filePath) {
       return "javascript";
     case ".jsx":
       return "jsx";
+    case ".py":
+      return "python";
     default:
       return null;
   }
@@ -531,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) {
@@ -591,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",
@@ -612,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(),
@@ -659,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,
@@ -691,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",
@@ -755,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);
@@ -802,7 +1221,7 @@ async function extractFile(input) {
         fromId: fileId,
         toId: "",
         line: startLine(node),
-        fromPath: input.relativePath,
+        fromPath: input3.relativePath,
         toPath: target,
         unresolvedTargetName: target
       });
@@ -812,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",
@@ -824,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",
@@ -843,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);
@@ -857,35 +1276,35 @@ 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 = (input.language === "tsx" || input.language === "jsx") && isPascalCase(name) && containsJsx(node.childForFieldName("body"));
+  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,
+    repoId: input3.repoId,
     kind,
-    path: input.relativePath,
+    path: input3.relativePath,
     name,
     line
   });
@@ -893,9 +1312,9 @@ function functionFromDeclaration(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: extractSignature(node, source),
@@ -905,7 +1324,7 @@ function functionFromDeclaration(node, input, 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);
@@ -913,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
   });
@@ -924,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}` : ""}`,
@@ -936,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
   });
@@ -952,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) ?? "",
@@ -963,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];
@@ -981,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
     });
@@ -991,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),
@@ -1004,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
   });
@@ -1014,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) ?? "",
@@ -1035,7 +1454,7 @@ 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");
@@ -1098,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") {
@@ -1110,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");
@@ -1127,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;
@@ -1153,17 +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,
-        ...input.tsconfigPaths ? { tsconfigPaths: input.tsconfigPaths } : {}
+        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;
@@ -1178,8 +1606,8 @@ function resolveEdges(input) {
   }
   return { resolved: out, dropped };
 }
-function resolveImportPath(input) {
-  const { fromPath, spec, known, tsconfigPaths } = input;
+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)));
@@ -1192,6 +1620,8 @@ function resolveImportPath(input) {
       if (resolved) return resolved;
     }
   }
+  const fromRoot = firstMatchingCandidate(toPosix(spec), known);
+  if (fromRoot) return fromRoot;
   return null;
 }
 function firstMatchingCandidate(joined, known) {
@@ -1199,7 +1629,7 @@ function firstMatchingCandidate(joined, known) {
   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;
   }
@@ -1238,7 +1668,7 @@ function toPosix(p) {
 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
@@ -1252,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);
@@ -1267,7 +1697,7 @@ async function embedNodes(nodes, opts) {
     }
     opts.onBatch?.({
       batchIndex: i / batchSize,
-      total,
+      total: totalSymbols,
       embedded: result.length
     });
   }
@@ -1305,14 +1735,14 @@ async function readIfExists(filePath) {
     return null;
   }
 }
-function stripJsonComments(input) {
+function stripJsonComments(input3) {
   let out = "";
   let i = 0;
   let inString = false;
   let stringChar = "";
-  while (i < input.length) {
-    const c = input[i];
-    const next = input[i + 1];
+  while (i < input3.length) {
+    const c = input3[i];
+    const next = input3[i + 1];
     if (inString) {
       out += c;
       if (c === "\\" && next !== void 0) {
@@ -1332,12 +1762,12 @@ function stripJsonComments(input) {
       continue;
     }
     if (c === "/" && next === "/") {
-      while (i < input.length && input[i] !== "\n") i++;
+      while (i < input3.length && input3[i] !== "\n") i++;
       continue;
     }
     if (c === "/" && next === "*") {
       i += 2;
-      while (i < input.length && !(input[i] === "*" && input[i + 1] === "/")) i++;
+      while (i < input3.length && !(input3[i] === "*" && input3[i + 1] === "/")) i++;
       i += 2;
       continue;
     }
@@ -1528,11 +1958,11 @@ async function runWithConcurrency(items, concurrency, fn) {
 import kleur4 from "kleur";
 
 // src/repo-id.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import path5 from "path";
 function repoIdFromPath(absPath) {
   const base = path5.basename(path5.resolve(absPath));
-  const sha = createHash3("sha1").update(path5.resolve(absPath)).digest("hex").slice(0, 8);
+  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}`;
 }
@@ -1692,18 +2122,21 @@ async function runWipeCommand(opts) {
 }
 
 // src/commands/init.ts
+import { spawn } from "child_process";
 import path7 from "path";
-import { confirm, password as password2, select as select2 } from "@inquirer/prompts";
+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 createHash4 } from "crypto";
+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 from "express";
+import express, { Router } from "express";
 import { z } from "zod";
 import { z as z2 } from "zod";
 import { z as z3 } from "zod";
@@ -1716,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) {
@@ -2079,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(";")) {
@@ -2313,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, {
@@ -2329,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) => {
@@ -2529,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-M7HSEMBT.js");
+    mod = await import("./src-IKWDKNPH.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)}`
@@ -2560,7 +3067,7 @@ async function loadGraphClient(dbPath) {
 async function loadLlmRouter(configPath2) {
   let mod;
   try {
-    mod = await import("./src-UVET6JHH.js");
+    mod = await import("./src-HB4UDUBX.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)}`
@@ -2659,62 +3166,202 @@ async function runLlmSetup() {
     message: "How would you like to power CodeGraph?",
     choices: [
       {
-        name: "Cloud provider",
-        value: "cloud",
-        description: "OpenAI, Anthropic, or Google. Fastest setup, requires an API key."
+        name: "Local, zero cost",
+        value: "local",
+        description: "Runs entirely on your laptop. No API keys. Uses Ollama (guided install)."
       },
       {
-        name: "Local (Ollama)",
-        value: "local",
-        description: "Fully private. Requires Ollama running on :11434."
+        name: "Cloud provider",
+        value: "cloud",
+        description: "OpenAI, Anthropic, or Google. Better quality, requires an API key."
       }
     ]
   });
-  let preset;
   if (mode === "local") {
-    preset = "local-ollama";
+    await setupLocalOllama();
   } else {
-    preset = await select2({
-      message: "Which cloud provider?",
+    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: "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"
-        }
+        { 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;
   }
-  const lookup = LLM_PRESETS[preset];
-  if (!lookup) {
-    throw new Error(`Unknown preset "${preset}".`);
+  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      ")}${kleur5.dim(namespaceLabel(config.llm))}`);
+  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.")
-    );
+    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;
@@ -2722,6 +3369,11 @@ async function runLlmSetup() {
   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";
@@ -2813,8 +3465,9 @@ async function runIndexStep() {
     return;
   }
   console.log();
+  const binPath = resolveBinPath();
   try {
-    await runIndexCommand({ repoPath: cwd });
+    await spawnIndex(binPath, cwd);
   } catch (err) {
     console.log();
     console.log(
@@ -2827,6 +3480,30 @@ async function runIndexStep() {
     );
   }
 }
+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({});
@@ -3004,6 +3681,10 @@ async function runCelebration() {
     `  ${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")}`,
@@ -3029,7 +3710,23 @@ function abbreviateHome(p) {
 }
 
 // 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";
@@ -3065,16 +3762,19 @@ async function runServeCommand(opts = {}) {
     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(`
@@ -3096,6 +3796,57 @@ 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();
@@ -3122,6 +3873,12 @@ 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();
   });
@@ -3154,4 +3911,4 @@ export {
   renderError,
   buildProgram
 };
-//# sourceMappingURL=chunk-5WYXRWEY.js.map
+//# sourceMappingURL=chunk-KYPDPBI5.js.map