sciogen 0.1.0__py3-none-any.whl

sciogen/__init__.py

@@ -0,0 +1,24 @@
+"""sciogen — a queryable knowledge graph over a codebase.
+
+sciogen is a static analysis and indexing tool. It parses source files with
+tree-sitter, normalizes them into a language-agnostic IR, resolves symbol
+references to exact definitions, and materializes the result into an embedded
+triple store (KuzuDB for graph topology, ChromaDB for vectors, SQLite for
+operational metadata). All queries are deterministic and return typed Python
+objects — never raw source code.
+
+Public entry point::
+
+    import sciogen
+
+    graph = sciogen.open("path/to/repo")   # opens (or creates) the index
+    graph.index()                          # incremental — only changed files
+    graph.get_callers("AuthService.login")
+    graph.search("password hashing logic", mode="hybrid")
+"""
+
+from sciogen.api import SciogenGraph, open  # noqa: A004 - deliberate, mirrors sqlite3.connect ergonomics
+
+__version__ = "0.1.0"
+
+__all__ = ["SciogenGraph", "open", "__version__"]

sciogen/api.py

@@ -0,0 +1,151 @@
+"""Public Python API — the :class:`SciogenGraph` facade.
+
+Everything else (CLI, MCP) is a thin adapter over this class. New
+capabilities are added here first; protocol layers only wrap.
+
+Stores open lazily: constructing a SciogenGraph is free, the KuzuDB/ChromaDB
+handles materialize on first use. That keeps `import sciogen` + CLI startup
+instant (chromadb alone costs seconds to import).
+"""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Any
+
+from sciogen.config import Config
+from sciogen.query.results import (
+    ContextBundle,
+    DependencyInfo,
+    DiffImpact,
+    ImpactGraph,
+    SearchResults,
+    SymbolInfo,
+)
+
+
+class SciogenGraph:
+    """A handle to one project's index (graph + vectors + metadata)."""
+
+    def __init__(self, project_root: str | Path, config: Config | None = None) -> None:
+        self.config = config or Config.for_project(project_root)
+        self._graph = None
+        self._vectors = None
+        self._meta = None
+        self._engine = None
+
+    # --------------------------------------------------------- lazy plumbing
+
+    @property
+    def graph_store(self):
+        if self._graph is None:
+            from sciogen.stores.graph import GraphStore
+
+            self._graph = GraphStore(self.config.graph_dir)
+        return self._graph
+
+    @property
+    def vector_store(self):
+        if self._vectors is None:
+            from sciogen.embed import get_embedder
+            from sciogen.stores.vectors import VectorStore
+
+            self._vectors = VectorStore(self.config.vector_dir, get_embedder(self.config.embedder))
+        return self._vectors
+
+    @property
+    def meta_store(self):
+        if self._meta is None:
+            from sciogen.stores.meta import MetaStore
+
+            self._meta = MetaStore(self.config.meta_path)
+        return self._meta
+
+    @property
+    def engine(self):
+        if self._engine is None:
+            from sciogen.query.engine import QueryEngine
+
+            self._engine = QueryEngine(self.graph_store, self.vector_store, self.meta_store)
+        return self._engine
+
+    # -------------------------------------------------------------- indexing
+
+    def index(self, reporter=None, rebuild: bool = False):
+        """Build or incrementally update the index. Returns IndexStats.
+
+        ``rebuild=True`` wipes the on-disk index first — needed after a
+        schema change or when switching embedders.
+        """
+        if rebuild:
+            self.close()
+            if self.config.data_dir.exists():
+                shutil.rmtree(self.config.data_dir)
+        from sciogen.index.pipeline import Pipeline
+
+        pipeline = Pipeline(
+            self.config, self.graph_store, self.vector_store, self.meta_store, reporter
+        )
+        return pipeline.run()
+
+    # -------------------------------------------------------------- querying
+
+    def get_symbol(self, name: str, file: str | None = None) -> SymbolInfo:
+        return self.engine.get_symbol(name, file)
+
+    def get_callers(self, symbol: str, depth: int = 1, min_confidence: float = 0.0) -> ImpactGraph:
+        return self.engine.get_callers(symbol, depth, min_confidence)
+
+    def get_dependencies(self, file: str) -> DependencyInfo:
+        return self.engine.get_dependencies(file.replace("\\", "/"))
+
+    def analyze_impact(
+        self, symbol: str, max_depth: int = 5, min_confidence: float = 0.0
+    ) -> ImpactGraph:
+        return self.engine.analyze_impact(symbol, max_depth, min_confidence)
+
+    def search(
+        self, query: str, mode: str = "semantic", granularity: str | None = None, k: int = 10
+    ) -> SearchResults:
+        return self.engine.search(query, mode, granularity, k)
+
+    def get_diff_impact(self, unified_diff: str) -> DiffImpact:
+        return self.engine.get_diff_impact(unified_diff)
+
+    def get_context_for_task(self, description: str, k: int = 15) -> ContextBundle:
+        return self.engine.get_context_for_task(description, k)
+
+    # ------------------------------------------------------- explore support
+
+    def snapshot(self, path_prefix: str = "") -> dict[str, Any]:
+        """Full graph serialization for `sciogen explore` (nodes, edges,
+        in-degrees). Not part of the agent-facing API."""
+        return {
+            "nodes": self.graph_store.all_nodes(path_prefix),
+            "edges": self.graph_store.all_edges(),
+            "in_degrees": self.graph_store.in_degrees(),
+        }
+
+    # ------------------------------------------------------------- lifecycle
+
+    def close(self) -> None:
+        if self._graph is not None:
+            self._graph.close()
+            self._graph = None
+        if self._meta is not None:
+            self._meta.close()
+            self._meta = None
+        self._vectors = None  # chromadb PersistentClient has no close()
+        self._engine = None
+
+    def __enter__(self) -> "SciogenGraph":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+
+def open(project_root: str | Path) -> SciogenGraph:  # noqa: A001
+    """Open (or create) the sciogen index for a project directory."""
+    return SciogenGraph(project_root)

sciogen/cli/__init__.py

@@ -0,0 +1 @@
+"""Typer + Rich CLI. All output goes through the shared Console singleton."""

sciogen/cli/banner.py

@@ -0,0 +1,19 @@
+"""ASCII banner shown by `sciogen index`.
+
+Kept as a plain string constant (project rule: never generated
+programmatically). Printed unstyled — plain text only.
+"""
+
+BANNER = r"""
+  ███████╗ ██████╗██╗ ██████╗  ██████╗ ███████╗███╗   ██╗
+  ██╔════╝██╔════╝██║██╔═══██╗██╔════╝ ██╔════╝████╗  ██║
+  ███████╗██║     ██║██║   ██║██║  ███╗█████╗  ██╔██╗ ██║
+  ╚════██║██║     ██║██║   ██║██║   ██║██╔══╝  ██║╚██╗██║
+  ███████║╚██████╗██║╚██████╔╝╚██████╔╝███████╗██║ ╚████║
+  ╚══════╝ ╚═════╝╚═╝ ╚═════╝  ╚═════╝ ╚══════╝╚═╝  ╚═══╝
+  Codebase Intelligence Layer  v{version}
+"""
+
+
+def banner_text(version: str) -> str:
+    return BANNER.format(version=version)

sciogen/cli/console.py

@@ -0,0 +1,10 @@
+"""The module-level Rich Console singleton.
+
+Every CLI module imports this instance; nothing in the CLI layer calls
+``print()`` or instantiates its own Console (project rule — one console
+means consistent styling, correct terminal detection, and testable output).
+"""
+
+from rich.console import Console
+
+console = Console()

sciogen/cli/explore/__init__.py

@@ -0,0 +1,57 @@
+"""`sciogen explore` HTML generation.
+
+Serializes the full graph snapshot into the static template
+(``template.html``, kept as an asset with a ``{{GRAPH_JSON}}`` placeholder —
+never built by string concatenation) and writes a single self-contained HTML
+file. No server, no port; the browser gets everything upfront and progressive
+disclosure happens client-side.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+_TEMPLATE_PATH = Path(__file__).parent / "template.html"
+
+#: ChunkNodes are embedding units, not something a human inspects on a canvas.
+_HIDDEN_KINDS = {"ChunkNode"}
+#: Node properties worth showing in the side panel (same shape as get_symbol).
+_PANEL_PROPS = (
+    "file", "language", "line_start", "line_end", "params", "return_type",
+    "complexity", "extends", "implements", "docstring", "fields", "size", "package",
+)
+
+
+def generate_html(snapshot: dict[str, Any], project: str, out_path: Path) -> Path:
+    hidden = {n["id"] for n in snapshot["nodes"] if n["kind"] in _HIDDEN_KINDS}
+    nodes = [
+        {
+            "id": n["id"],
+            "kind": n["kind"],
+            "name": n["name"],
+            "props": {k: n[k] for k in _PANEL_PROPS if n.get(k)},
+        }
+        for n in snapshot["nodes"]
+        if n["kind"] not in _HIDDEN_KINDS
+    ]
+    edges = [
+        {"src": src, "dst": dst, "kind": kind, "confidence": round(conf, 2)}
+        for src, dst, kind, conf in snapshot["edges"]
+        if src not in hidden and dst not in hidden
+    ]
+    payload = {
+        "nodes": nodes,
+        "edges": edges,
+        "in_degrees": {k: v for k, v in snapshot["in_degrees"].items() if k not in hidden},
+    }
+    graph_json = json.dumps(payload, separators=(",", ":")).replace("</", "<\\/")
+    html = (
+        _TEMPLATE_PATH.read_text(encoding="utf-8")
+        .replace("{{GRAPH_JSON}}", graph_json)
+        .replace("{{PROJECT}}", project)
+    )
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(html, encoding="utf-8")
+    return out_path

sciogen/cli/explore/template.html

@@ -0,0 +1,341 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>sciogen — {{PROJECT}}</title>
+<script src="https://cdn.jsdelivr.net/npm/cytoscape@3.30.2/dist/cytoscape.min.js"></script>
+<style>
+  :root {
+    --surface: #fcfcfb; --page: #f9f9f7; --ink: #0b0b0b; --ink-2: #52514e;
+    --muted: #898781; --hairline: #e1e0d9; --edge: #c3c2b7;
+    --border: rgba(11,11,11,0.10);
+    --c-file: #2a78d6; --c-class: #1baf7a; --c-function: #eda100;
+    --c-type: #008300; --c-module: #4a3aa7; --c-external: #e34948;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --surface: #1a1a19; --page: #0d0d0d; --ink: #ffffff; --ink-2: #c3c2b7;
+      --muted: #898781; --hairline: #2c2c2a; --edge: #383835;
+      --border: rgba(255,255,255,0.10);
+      --c-file: #3987e5; --c-class: #199e70; --c-function: #c98500;
+      --c-type: #008300; --c-module: #9085e9; --c-external: #e66767;
+    }
+  }
+  * { box-sizing: border-box; margin: 0; }
+  body {
+    font-family: system-ui, -apple-system, "Segoe UI", sans-serif;
+    background: var(--page); color: var(--ink); height: 100vh;
+    display: flex; flex-direction: column; overflow: hidden;
+  }
+  header {
+    display: flex; align-items: center; gap: 16px; padding: 10px 16px;
+    border-bottom: 1px solid var(--hairline); background: var(--surface);
+    flex-wrap: wrap;
+  }
+  header h1 { font-size: 15px; font-weight: 600; }
+  header h1 span { color: var(--muted); font-weight: 400; }
+  #search {
+    flex: 1; min-width: 180px; max-width: 360px; padding: 6px 10px;
+    border: 1px solid var(--hairline); border-radius: 6px;
+    background: var(--page); color: var(--ink); font: inherit; font-size: 13px;
+  }
+  #search:focus { outline: 2px solid var(--c-file); outline-offset: -1px; }
+  .layout-toggle { display: flex; border: 1px solid var(--hairline); border-radius: 6px; overflow: hidden; }
+  .layout-toggle button {
+    font: inherit; font-size: 12px; padding: 6px 12px; border: 0; cursor: pointer;
+    background: var(--surface); color: var(--ink-2);
+  }
+  .layout-toggle button.active { background: var(--c-file); color: #fff; }
+  .legend { display: flex; gap: 12px; flex-wrap: wrap; font-size: 12px; color: var(--ink-2); }
+  .legend .item { display: flex; align-items: center; gap: 5px; }
+  .legend .swatch { width: 10px; height: 10px; display: inline-block; }
+  main { flex: 1; display: flex; min-height: 0; }
+  #cy { flex: 1; background: var(--surface); min-width: 0; }
+  #panel {
+    width: 320px; border-left: 1px solid var(--hairline); background: var(--surface);
+    padding: 16px; overflow-y: auto; display: none; font-size: 13px;
+  }
+  #panel.open { display: block; }
+  #panel h2 { font-size: 14px; word-break: break-all; margin-bottom: 2px; }
+  #panel .kind { font-size: 11px; color: var(--muted); text-transform: uppercase; letter-spacing: .05em; margin-bottom: 12px; }
+  #panel dl { display: grid; grid-template-columns: 1fr; gap: 8px; }
+  #panel dt { color: var(--muted); font-size: 11px; text-transform: uppercase; letter-spacing: .04em; }
+  #panel dd { color: var(--ink-2); word-break: break-all; white-space: pre-wrap; }
+  #panel .close { float: right; cursor: pointer; border: 0; background: none; color: var(--muted); font-size: 16px; }
+  footer {
+    padding: 6px 16px; font-size: 12px; color: var(--muted);
+    border-top: 1px solid var(--hairline); background: var(--surface);
+    display: flex; gap: 16px; flex-wrap: wrap;
+  }
+  .edge-legend { display: flex; gap: 12px; }
+  .edge-legend svg { vertical-align: middle; }
+</style>
+</head>
+<body>
+<header>
+  <h1>{{PROJECT}} <span>· sciogen graph</span></h1>
+  <input id="search" type="search" placeholder="Jump to symbol… (Enter)"
+         aria-label="Search symbols by name">
+  <div class="layout-toggle" role="group" aria-label="Layout">
+    <button id="btn-force" class="active">Force</button>
+    <button id="btn-hier">Hierarchy</button>
+  </div>
+  <div class="legend" id="legend"></div>
+</header>
+<main>
+  <div id="cy" role="application" aria-label="Code knowledge graph"></div>
+  <aside id="panel" aria-live="polite">
+    <button class="close" id="panel-close" aria-label="Close panel">✕</button>
+    <h2 id="panel-title"></h2>
+    <div class="kind" id="panel-kind"></div>
+    <dl id="panel-props"></dl>
+  </aside>
+</main>
+<footer>
+  <span id="stats"></span>
+  <span class="edge-legend">
+    <span><svg width="26" height="8"><line x1="0" y1="4" x2="26" y2="4" stroke="currentColor" stroke-width="2"/></svg> confidence ≥ 0.8</span>
+    <span><svg width="26" height="8"><line x1="0" y1="4" x2="26" y2="4" stroke="currentColor" stroke-width="2" stroke-dasharray="6 3"/></svg> 0.5 – 0.8</span>
+    <span><svg width="26" height="8"><line x1="0" y1="4" x2="26" y2="4" stroke="currentColor" stroke-width="2" stroke-dasharray="2 3"/></svg> &lt; 0.5</span>
+  </span>
+  <span>Click a file to expand its symbols · click a function to reveal its calls · click again to collapse</span>
+</footer>
+<script>
+const GRAPH = {{GRAPH_JSON}};
+
+// ---------------------------------------------------------------- palette
+const KINDS = {
+  FileNode:     { varName: "--c-file",     shape: "round-rectangle", label: "File" },
+  ClassNode:    { varName: "--c-class",    shape: "hexagon",         label: "Class" },
+  FunctionNode: { varName: "--c-function", shape: "ellipse",         label: "Function" },
+  TypeNode:     { varName: "--c-type",     shape: "diamond",         label: "Type" },
+  ModuleNode:   { varName: "--c-module",   shape: "barrel",          label: "Module" },
+  ExternalNode: { varName: "--c-external", shape: "octagon",         label: "External" },
+};
+const css = name => getComputedStyle(document.documentElement).getPropertyValue(name).trim();
+const kindColor = kind => css((KINDS[kind] || KINDS.ExternalNode).varName);
+
+// Legend (color + shape name — identity is never color-alone)
+document.getElementById("legend").innerHTML = Object.values(KINDS).map(k =>
+  `<span class="item"><span class="swatch" style="background:${css(k.varName)};
+   border-radius:${k.shape === "ellipse" ? "50%" : "2px"}"></span>${k.label}</span>`).join("");
+
+// ------------------------------------------------------------- data prep
+const nodesById = new Map(GRAPH.nodes.map(n => [n.id, n]));
+const childrenOf = new Map();   // DEFINES: parent id -> [child ids]
+const parentOf = new Map();
+const adjacency = new Map();    // id -> edges touching it
+for (const n of GRAPH.nodes) adjacency.set(n.id, []);
+for (const e of GRAPH.edges) {
+  if (e.kind === "DEFINES") {
+    if (!childrenOf.has(e.src)) childrenOf.set(e.src, []);
+    childrenOf.get(e.src).push(e.dst);
+    parentOf.set(e.dst, e.src);
+  }
+  if (adjacency.has(e.src)) adjacency.get(e.src).push(e);
+  if (adjacency.has(e.dst)) adjacency.get(e.dst).push(e);
+}
+const degree = id => GRAPH.in_degrees[id] || 0;
+const maxDegree = Math.max(1, ...Object.values(GRAPH.in_degrees));
+const nodeSize = id => 22 + 38 * Math.sqrt(degree(id) / maxDegree);
+const shortLabel = n => n.kind === "FileNode"
+  ? n.name.split("/").pop()
+  : (n.name.split(".").pop() || n.name);
+
+// Collapsed by default: files only. revealedBy tracks progressive disclosure
+// so collapse can undo exactly what an expansion added.
+const visible = new Set(GRAPH.nodes.filter(n => n.kind === "FileNode").map(n => n.id));
+const revealedBy = new Map();   // node id -> id of the node that revealed it
+const expanded = new Set();
+
+// ------------------------------------------------------------- cytoscape
+function edgeStyleClass(conf) { return conf >= 0.8 ? "solid" : conf >= 0.5 ? "dashed" : "dotted"; }
+
+function buildElements() {
+  const els = [];
+  for (const id of visible) {
+    const n = nodesById.get(id);
+    if (!n) continue;
+    els.push({ data: { id, label: shortLabel(n), kind: n.kind, size: nodeSize(id) } });
+  }
+  const seen = new Set();
+  for (const e of GRAPH.edges) {
+    if (e.kind === "DEFINES" || e.kind === "PART_OF") continue;  // structure is shown by expansion
+    if (!visible.has(e.src) || !visible.has(e.dst)) continue;
+    const key = e.src + "→" + e.dst + "→" + e.kind;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    els.push({ data: { id: key, source: e.src, target: e.dst, kind: e.kind,
+                       confidence: e.confidence }, classes: edgeStyleClass(e.confidence) });
+  }
+  return els;
+}
+
+function cyStyle() {
+  return [
+    { selector: "node", style: {
+        "background-color": ele => kindColor(ele.data("kind")),
+        "shape": ele => (KINDS[ele.data("kind")] || KINDS.ExternalNode).shape,
+        "width": "data(size)", "height": "data(size)",
+        "label": "data(label)", "font-size": 10, "font-family": "system-ui, sans-serif",
+        "color": css("--ink-2"), "text-valign": "bottom", "text-margin-y": 4,
+        "border-width": 1, "border-color": css("--border"),
+        "text-wrap": "ellipsis", "text-max-width": 120,
+    }},
+    { selector: "node:selected", style: { "border-width": 3, "border-color": css("--ink") } },
+    { selector: "edge", style: {
+        "width": 2, "line-color": css("--edge"), "curve-style": "bezier",
+        "target-arrow-shape": "triangle", "target-arrow-color": css("--edge"),
+        "arrow-scale": 0.8,
+    }},
+    { selector: "edge.dashed", style: { "line-style": "dashed" } },
+    { selector: "edge.dotted", style: { "line-style": "dotted" } },
+    { selector: "edge:selected", style: { "line-color": css("--ink"), "target-arrow-color": css("--ink") } },
+  ];
+}
+
+const LAYOUTS = {
+  force: { name: "cose", animate: false, nodeRepulsion: 40000, idealEdgeLength: 90, padding: 30 },
+  hier:  { name: "breadthfirst", directed: true, spacingFactor: 1.2, padding: 30 },
+};
+let currentLayout = "force";
+
+const cy = cytoscape({
+  container: document.getElementById("cy"),
+  elements: buildElements(),
+  style: cyStyle(),
+  layout: LAYOUTS[currentLayout],
+  wheelSensitivity: 0.25,
+});
+
+function refresh(fit) {
+  cy.json({ elements: buildElements() });
+  cy.style(cyStyle());
+  const layout = cy.layout(LAYOUTS[currentLayout]);
+  layout.run();
+  if (fit) cy.fit(undefined, 40);
+  updateStats();
+}
+
+function updateStats() {
+  document.getElementById("stats").textContent =
+    `${visible.size} of ${GRAPH.nodes.length} nodes shown · ${GRAPH.edges.length} edges total`;
+}
+
+// ------------------------------------------------- expand / collapse logic
+function reveal(id, by) {
+  if (visible.has(id)) return;
+  visible.add(id);
+  revealedBy.set(id, by);
+}
+
+function expandNode(id) {
+  const n = nodesById.get(id);
+  if (!n) return;
+  expanded.add(id);
+  for (const child of (childrenOf.get(id) || [])) {
+    const c = nodesById.get(child);
+    if (c && c.kind !== "ChunkNode") reveal(child, id);
+  }
+  if (n.kind === "FileNode") {
+    for (const e of (adjacency.get(id) || []))
+      if (e.kind === "IMPORTS" && e.src === id) reveal(e.dst, id);
+  }
+  if (n.kind === "FunctionNode") {
+    for (const e of (adjacency.get(id) || []))
+      if (e.kind === "CALLS") reveal(e.src === id ? e.dst : e.src, id);
+  }
+}
+
+function collapseNode(id) {
+  expanded.delete(id);
+  const toRemove = [...revealedBy.entries()].filter(([, by]) => by === id).map(([k]) => k);
+  for (const child of toRemove) {
+    if (expanded.has(child)) collapseNode(child);
+    visible.delete(child);
+    revealedBy.delete(child);
+  }
+}
+
+cy.on("tap", "node", evt => {
+  const id = evt.target.id();
+  showPanel(nodesById.get(id));
+  if (expanded.has(id)) collapseNode(id); else expandNode(id);
+  refresh(false);
+});
+cy.on("tap", "edge", evt => {
+  const d = evt.target.data();
+  showEdgePanel(d);
+});
+cy.on("tap", evt => { if (evt.target === cy) hidePanel(); });
+
+// ---------------------------------------------------------------- panel
+const panel = document.getElementById("panel");
+function showPanel(n) {
+  if (!n) return;
+  document.getElementById("panel-title").textContent = n.name;
+  document.getElementById("panel-kind").textContent = n.kind;
+  const props = Object.entries(n.props || {}).filter(([, v]) =>
+    v !== "" && v !== 0 && !(Array.isArray(v) && !v.length));
+  document.getElementById("panel-props").innerHTML = props.map(([k, v]) =>
+    `<div><dt>${k}</dt><dd>${escapeHtml(Array.isArray(v) ? v.join(", ") : String(v))}</dd></div>`).join("");
+  panel.classList.add("open");
+}
+function showEdgePanel(d) {
+  document.getElementById("panel-title").textContent = `${d.source} → ${d.target}`;
+  document.getElementById("panel-kind").textContent = d.kind + " edge";
+  document.getElementById("panel-props").innerHTML =
+    `<div><dt>confidence</dt><dd>${d.confidence}</dd></div>`;
+  panel.classList.add("open");
+}
+function hidePanel() { panel.classList.remove("open"); }
+document.getElementById("panel-close").onclick = hidePanel;
+function escapeHtml(s) { const d = document.createElement("div"); d.textContent = s; return d.innerHTML; }
+
+// ---------------------------------------------------------------- search
+document.getElementById("search").addEventListener("keydown", evt => {
+  if (evt.key !== "Enter") return;
+  const q = evt.target.value.trim().toLowerCase();
+  if (!q) return;
+  const match = GRAPH.nodes.find(n => n.kind !== "ChunkNode" && n.name.toLowerCase() === q)
+    || GRAPH.nodes.find(n => n.kind !== "ChunkNode" && n.name.toLowerCase().includes(q));
+  if (!match) return;
+  // Reveal the ancestor chain (file -> class -> symbol), then the node.
+  const chain = [];
+  let cur = match.id;
+  while (parentOf.has(cur)) { cur = parentOf.get(cur); chain.unshift(cur); }
+  for (const ancestor of chain) expandNode(ancestor);
+  reveal(match.id, chain[chain.length - 1] || match.id);
+  refresh(false);
+  const target = cy.getElementById(match.id);
+  if (target.nonempty()) {
+    cy.animate({ center: { eles: target }, zoom: 1.4, duration: 350 });
+    target.select();
+    showPanel(match);
+  }
+});
+
+// ---------------------------------------------------------- layout toggle
+const btnForce = document.getElementById("btn-force");
+const btnHier = document.getElementById("btn-hier");
+function setLayout(name) {
+  currentLayout = name;
+  btnForce.classList.toggle("active", name === "force");
+  btnHier.classList.toggle("active", name === "hier");
+  refresh(true);
+}
+btnForce.onclick = () => setLayout("force");
+btnHier.onclick = () => setLayout("hier");
+
+// Re-style when the OS theme flips.
+window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change",
+  () => { cy.style(cyStyle()); document.getElementById("legend").innerHTML =
+    Object.values(KINDS).map(k => `<span class="item"><span class="swatch" style="background:${css(k.varName)};
+    border-radius:${k.shape === "ellipse" ? "50%" : "2px"}"></span>${k.label}</span>`).join(""); });
+
+updateStats();
+cy.fit(undefined, 40);
+</script>
+</body>
+</html>