context-mcp-server 1.0.8 → 1.1.1

package/codegraph/graph/symbol_resolution.py

@@ -0,0 +1,112 @@
+"""
+graph/symbol_resolution.py — cross-file call edge resolution.
+
+Resolves unresolved callee names in node['calls'] to actual node IDs,
+creating 'calls' edges with INFERRED confidence where a unique match exists.
+
+Our nodes use 'name'/'file' (graphify uses 'label'/'source_file').
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def build_name_index(all_nodes: list[dict]) -> dict[str, list[str]]:
+    """Map symbol name → [node_ids] for function/class/struct nodes."""
+    index: dict[str, list[str]] = {}
+    callable_types = {"function", "method", "class", "struct", "interface", "trait"}
+    for node in all_nodes:
+        if node.get("type") in callable_types:
+            name = node.get("name", "")
+            nid = node.get("id", "")
+            if name and nid:
+                index.setdefault(name, []).append(nid)
+    return index
+
+
+def build_module_name_index(all_nodes: list[dict]) -> dict[tuple[str, str], list[str]]:
+    """Map (module_stem, symbol_name) → [node_ids] for scoped resolution."""
+    index: dict[tuple[str, str], list[str]] = {}
+    callable_types = {"function", "method", "class", "struct", "interface", "trait"}
+    for node in all_nodes:
+        if node.get("type") in callable_types:
+            name = node.get("name", "")
+            nid = node.get("id", "")
+            file_path = node.get("file", "")
+            if name and nid and file_path:
+                stem = Path(file_path.replace("\\", "/")).stem
+                index.setdefault((stem, name), []).append(nid)
+    return index
+
+
+def resolve_calls(
+    all_nodes: list[dict],
+    existing_edge_keys: set[tuple[str, str]],
+) -> list[dict]:
+    """Resolve node['calls'] lists to graph edges.
+
+    For each node that declares `calls: ["FunctionName", ...]`, look up the
+    name in the global index. Only emit an edge when the name resolves
+    uniquely (avoids false positives for common names like 'get' or 'init').
+
+    Returns a list of new edge dicts {from, to, relation, confidence}.
+    """
+    name_index = build_name_index(all_nodes)
+    module_index = build_module_name_index(all_nodes)
+
+    new_edges: list[dict] = []
+
+    for node in all_nodes:
+        caller_id = node.get("id", "")
+        if not caller_id:
+            continue
+        calls = node.get("calls", [])
+        if not calls:
+            continue
+
+        caller_file = node.get("file", "")
+        # Try module-scoped resolution first (same file prefix → higher confidence)
+        imports = node.get("imports", [])
+        imported_stems = set()
+        for imp in imports:
+            clean = imp.lstrip(".").replace("\\", "/")
+            stem = Path(clean).stem
+            if stem:
+                imported_stems.add(stem)
+
+        for callee_name in calls:
+            if not isinstance(callee_name, str) or not callee_name:
+                continue
+
+            target_ids: list[str] = []
+
+            # 1. Try (imported_module_stem, callee_name) for import-guided resolution
+            for stem in imported_stems:
+                candidates = module_index.get((stem, callee_name), [])
+                target_ids.extend(candidates)
+
+            # 2. Fall back to global unique name match
+            if not target_ids:
+                target_ids = name_index.get(callee_name, [])
+
+            # Only emit when unambiguous
+            if len(target_ids) != 1:
+                continue
+
+            target_id = target_ids[0]
+            if target_id == caller_id:
+                continue  # skip self-calls
+            key = (caller_id, target_id)
+            if key in existing_edge_keys:
+                continue
+
+            existing_edge_keys.add(key)
+            confidence = "EXTRACTED" if imported_stems else "INFERRED"
+            new_edges.append({
+                "from":       caller_id,
+                "to":         target_id,
+                "relation":   "calls",
+                "confidence": confidence,
+            })
+
+    return new_edges

package/codegraph/report.py

@@ -84,10 +84,63 @@ def _build_report(g: dict) -> str:
     lines += ["## Confidence Breakdown", ""]
     for label, count in sorted(conf_counts.items()):
         lines.append(f"- **{label}**: {count} edges")
+    lines.append("")
+
+    # Knowledge gaps
+    lines += _knowledge_gaps_section(nodes, edges, communities, node_map)
 
     return "\n".join(lines)
 
 
+def _knowledge_gaps_section(
+    nodes: list, edges: list, communities: list, node_map: dict
+) -> list[str]:
+    """Identify under-connected areas: isolated nodes, thin communities, ambiguous edges."""
+    lines = ["## Knowledge Gaps", ""]
+
+    # Isolated nodes (no edges at all)
+    connected_ids: set[str] = set()
+    for e in edges:
+        connected_ids.add(e.get("from", ""))
+        connected_ids.add(e.get("to", ""))
+    isolated = [n for n in nodes if n["id"] not in connected_ids]
+    if isolated:
+        lines.append(f"**Isolated nodes** ({len(isolated)} with no edges):")
+        for n in isolated[:8]:
+            lines.append(f"  - `{n.get('name', n['id'])}` in `{n.get('file', '?')}`")
+        if len(isolated) > 8:
+            lines.append(f"  - …and {len(isolated) - 8} more")
+    else:
+        lines.append("_No isolated nodes._")
+    lines.append("")
+
+    # Thin communities (single-node clusters)
+    thin = [c for c in communities if len(c.get("members", [])) == 1]
+    if thin:
+        lines.append(f"**Thin communities** ({len(thin)} single-node clusters):")
+        for c in thin[:5]:
+            nid = c["members"][0]
+            n = node_map.get(nid, {})
+            lines.append(f"  - `{n.get('name', nid)}` in `{n.get('file', '?')}`")
+        if len(thin) > 5:
+            lines.append(f"  - …and {len(thin) - 5} more")
+    else:
+        lines.append("_No thin communities._")
+    lines.append("")
+
+    # High-ambiguity edges
+    ambiguous = [e for e in edges if e.get("confidence") == "AMBIGUOUS"]
+    if ambiguous and edges:
+        pct = round(100 * len(ambiguous) / len(edges), 1)
+        lines.append(f"**Ambiguous edges**: {len(ambiguous)} of {len(edges)} ({pct}%) "
+                     "have low-confidence resolution — consider adding type annotations.")
+    else:
+        lines.append("_No ambiguous edges._")
+    lines.append("")
+
+    return lines
+
+
 def _cross_module_edges(edges: list, node_map: dict) -> list[tuple]:
     results = []
     for e in edges:

package/codegraph/server.py

@@ -3,11 +3,12 @@
 codegraph/server.py — MCP server exposing codebase knowledge graph tools.
 
 Tools:
-  codegraph_build   — scan project, extract AST nodes, build graph (local only, no API)
-  codegraph_query   — structural question OR single-node lookup (or both); replaces codegraph_explain
-  codegraph_report  — return full CODEGRAPH_REPORT.md
-  codegraph_nodes   — list nodes of a given type
-  codegraph_path    — shortest path between two concepts
+  codegraph_build    — scan project, extract AST nodes, build graph (local only, no API)
+  codegraph_query    — structural question OR single-node lookup (or both)
+  codegraph_arch     — module map: every file with its exports and imports
+  codegraph_report   — return full CODEGRAPH_REPORT.md
+  codegraph_nodes    — list nodes of a given type
+  codegraph_affected — BFS: what breaks if I change node X?
 """
 
 import asyncio
@@ -25,9 +26,13 @@ from .config import classify_file
 from .cache import file_hash, set_cached_nodes, save_cache
 from .extractors.ast_extractor import extract as ast_extract
 from .graph.builder import build, to_json_dict, save_graph, load_graph
-from .graph.query import answer as graph_answer, find_path
+from .graph.query import answer as graph_answer, module_map
 from .graph.clustering import detect_communities
 from .report import generate as generate_report
+from .affected import run_affected
+from .export import to_html as export_html, to_graphml, to_obsidian, generate_all as export_all
+from .tree_html import to_html as tree_html
+from .callflow_html import to_html as callflow_html
 
 app = Server("codegraph")
 
@@ -95,16 +100,53 @@ TOOLS = [
         },
     ),
     Tool(
-        name="codegraph_path",
-        description="Find the shortest relationship path between two concepts in the graph.",
+        name="codegraph_html",
+        description=(
+            "Generate interactive vis.js HTML graph visualization. "
+            "Dark theme, search box, community toggle, click-to-inspect node panel. "
+            "Outputs codegraph-cache/graph.html. Also generates graph.graphml and obsidian/ vault."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "path":    {"type": "string", "description": "Project root"},
+                "formats": {"type": "array", "items": {"type": "string"}, "description": "Formats to generate: html, graphml, obsidian, tree, callflow (default: all)"},
+            },
+            "required": ["path"],
+        },
+    ),
+    Tool(
+        name="codegraph_affected",
+        description=(
+            "BFS traversal: given a node name, find every node that would be affected "
+            "if you change it — callers, importers, inheritors, etc. "
+            "Use before refactoring to understand blast radius. "
+            "Returns affected nodes with file paths, relation types, and traversal depth."
+        ),
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "path":  {"type": "string", "description": "Project root"},
+                "node":  {"type": "string", "description": "Node name, ID, or file path to start from"},
+                "depth": {"type": "integer", "description": "BFS depth (default 2, max 5)"},
+            },
+            "required": ["path", "node"],
+        },
+    ),
+    Tool(
+        name="codegraph_arch",
+        description=(
+            "Return a module map: every file with its exported functions/classes and what it imports. "
+            "Use this to understand project structure without reading any files. "
+            "Call after codegraph_build. Much faster than reading each file."
+        ),
         inputSchema={
             "type": "object",
             "properties": {
-                "path": {"type": "string"},
-                "from": {"type": "string"},
-                "to":   {"type": "string"},
+                "path":  {"type": "string", "description": "Project root"},
+                "limit": {"type": "integer", "description": "Max files in output (default 100)"},
             },
-            "required": ["path", "from", "to"],
+            "required": ["path"],
         },
     ),
 ]
@@ -125,12 +167,13 @@ async def call_tool(name: str, arguments: dict):
 
 
 async def _dispatch(name: str, args: dict):
-    if name == "codegraph_build":   return await _build(args)
-    if name == "codegraph_query":   return await _query(args)
-    if name == "codegraph_explain": return await _query(args)
-    if name == "codegraph_report":  return await _report(args)
-    if name == "codegraph_nodes":   return await _nodes(args)
-    if name == "codegraph_path":    return await _path(args)
+    if name == "codegraph_build":    return await _build(args)
+    if name == "codegraph_query":    return await _query(args)
+    if name == "codegraph_report":   return await _report(args)
+    if name == "codegraph_nodes":    return await _nodes(args)
+    if name == "codegraph_arch":     return await _arch(args)
+    if name == "codegraph_affected": return await _affected(args)
+    if name == "codegraph_html":     return await _export_viz(args)
     raise ValueError(f"Unknown tool: {name}")
 
 
@@ -188,6 +231,10 @@ async def _build(args: dict) -> dict:
     save_graph(root, graph_dict)
     generate_report(graph_dict, root)
     save_cache(root, cache)
+    try:
+        export_all(graph_dict, root)
+    except Exception:
+        pass
 
     elapsed_ms = int((time.time() - t0) * 1000)
     result = {
@@ -285,11 +332,56 @@ async def _nodes(args: dict) -> dict:
     return {"type": node_type, "count": len(matched), "nodes": matched[:limit]}
 
 
-async def _path(args: dict) -> dict:
+async def _arch(args: dict) -> dict:
+    graph_dict = load_graph(args["path"])
+    if not graph_dict:
+        raise ValueError("No graph found. Run codegraph_build first.")
+    limit = args.get("limit", 100)
+    return module_map(graph_dict, limit=limit)
+
+
+async def _affected(args: dict) -> dict:
     graph_dict = load_graph(args["path"])
     if not graph_dict:
         raise ValueError("No graph found. Run codegraph_build first.")
-    return find_path(args["from"], args["to"], graph_dict)
+    depth = min(int(args.get("depth", 2)), 5)
+    return run_affected(graph_dict, args["node"], depth=depth)
+
+
+async def _export_viz(args: dict) -> dict:
+    graph_dict = load_graph(args["path"])
+    if not graph_dict:
+        raise ValueError("No graph found. Run codegraph_build first.")
+    cache_dir = str(Path(args["path"]) / "codegraph-cache")
+    formats = args.get("formats") or ["html", "graphml", "obsidian", "tree", "callflow"]
+    results: dict[str, str] = {}
+    if "html" in formats:
+        try:
+            results["html"] = export_html(graph_dict, str(Path(cache_dir) / "graph.html"))
+        except Exception as e:
+            results["html_error"] = str(e)
+    if "graphml" in formats:
+        try:
+            results["graphml"] = to_graphml(graph_dict, str(Path(cache_dir) / "graph.graphml"))
+        except Exception as e:
+            results["graphml_error"] = str(e)
+    if "obsidian" in formats:
+        try:
+            results["obsidian"] = to_obsidian(graph_dict, str(Path(cache_dir) / "obsidian"))
+        except Exception as e:
+            results["obsidian_error"] = str(e)
+    if "tree" in formats:
+        try:
+            results["tree"] = tree_html(graph_dict, str(Path(cache_dir) / "tree.html"))
+        except Exception as e:
+            results["tree_error"] = str(e)
+    if "callflow" in formats:
+        try:
+            results["callflow"] = callflow_html(graph_dict, str(Path(cache_dir) / "callflow.html"))
+        except Exception as e:
+            results["callflow_error"] = str(e)
+    results["summary"] = f"Generated: {', '.join(k for k in results if not k.endswith('_error'))}"
+    return results
 
 
 # ── Entry point ───────────────────────────────────────────────────────────────

package/codegraph/tree_html.py

@@ -0,0 +1,241 @@
+"""
+tree_html.py — D3 v7 collapsible file-tree HTML from graph.json.
+
+Adapted from graphify's tree_html.py.
+Field name differences from graphify: we use 'file' not 'source_file', 'name' not 'label'.
+"""
+from __future__ import annotations
+
+import html as _html
+import json
+from collections import defaultdict
+from pathlib import Path
+
+DEFAULT_MAX_CHILDREN = 200
+
+
+# ── Tree builder ──────────────────────────────────────────────────────────────
+
+def _common_root(paths: list[str]) -> str:
+    if not paths:
+        return ""
+    parts = [Path(p.replace("\\", "/")).parts for p in paths if p]
+    if not parts:
+        return ""
+    common = list(parts[0])
+    for p in parts[1:]:
+        i = 0
+        while i < len(common) and i < len(p) and common[i] == p[i]:
+            i += 1
+        common = common[:i]
+    return str(Path(*common)) if common else ""
+
+
+def build_tree(
+    graph_dict: dict,
+    *,
+    root: str | None = None,
+    max_children: int = DEFAULT_MAX_CHILDREN,
+    project_label: str | None = None,
+) -> dict:
+    """Build {name, total_count, children} hierarchy from graph nodes."""
+    nodes = graph_dict.get("nodes", [])
+    file_nodes = [n for n in nodes if n.get("file")]
+    if not file_nodes:
+        return {"name": "(empty graph)", "total_count": 0, "children": []}
+
+    if root is None:
+        root = _common_root([n["file"].replace("\\", "/") for n in file_nodes])
+    root_path = Path(root.replace("\\", "/")) if root else Path(".")
+
+    by_file: dict[str, list[dict]] = defaultdict(list)
+    for n in file_nodes:
+        by_file[n["file"].replace("\\", "/")].append(n)
+
+    dir_index: dict[str, dict] = {}
+    label_root = project_label or root_path.name or root or "/"
+    root_node: dict = {"name": label_root, "total_count": 0, "children": []}
+    dir_index[str(root_path)] = root_node
+
+    def _ensure_dir(abs_path: Path) -> dict:
+        key = str(abs_path)
+        if key in dir_index:
+            return dir_index[key]
+        if abs_path == abs_path.parent:
+            return root_node
+        parent = _ensure_dir(abs_path.parent) if abs_path.parent != abs_path else root_node
+        node = {"name": abs_path.name, "total_count": 0, "children": []}
+        dir_index[key] = node
+        parent["children"].append(node)
+        return node
+
+    for src_file, syms in sorted(by_file.items()):
+        src_path = Path(src_file)
+        try:
+            rel = src_path.relative_to(root_path)
+            parent_path = (root_path / rel).parent
+        except ValueError:
+            parent_path = root_path
+        parent_dir = _ensure_dir(parent_path)
+
+        sym_children = []
+        for n in syms:
+            sym_name = n.get("name", n.get("id", "?"))
+            if sym_name == src_path.name:
+                continue
+            sym_children.append({"name": sym_name, "total_count": 1, "children": []})
+        sym_children.sort(key=lambda c: (c["name"].startswith("_"), c["name"].lower()))
+        if len(sym_children) > max_children:
+            extra = len(sym_children) - max_children
+            sym_children = sym_children[:max_children] + [{"name": f"(+{extra} more)", "total_count": extra, "children": []}]
+        file_node = {"name": src_path.name, "total_count": len(sym_children) or 1, "children": sym_children}
+        parent_dir["children"].append(file_node)
+
+    def _finalise(d: dict) -> int:
+        kids = d.get("children") or []
+        kids.sort(key=lambda c: (0 if (c.get("children") and len(c["children"]) > 0) else 1, c["name"].lower()))
+        if not kids:
+            return d.get("total_count") or 1
+        n = sum(_finalise(c) for c in kids)
+        d["total_count"] = n or 1
+        return d["total_count"]
+
+    _finalise(root_node)
+    return root_node
+
+
+# ── HTML emitter ──────────────────────────────────────────────────────────────
+
+_HTML_TEMPLATE = r"""<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>{title}</title>
+  <style>
+    body {{ font-family: 'Segoe UI', sans-serif; margin: 0; padding: 0; background: #f9f9f9; color: #333; }}
+    h1 {{ margin: 20px 0 0 24px; font-size: 2.2rem; font-weight: bold; color: #1e3a56; }}
+    .controls {{ margin: 20px 0 15px 24px; }}
+    button {{ margin-right: 10px; padding: 8px 18px; background: #007bff; color: #fff; border: none; border-radius: 5px; font-size: 0.95rem; cursor: pointer; }}
+    button:hover {{ background: #0056b3; }}
+    #tree-container {{ width: calc(100vw - 48px); height: 85vh; overflow: auto; border-radius: 8px; background: #fff; margin-left: 24px; box-shadow: 0 4px 12px rgba(0,0,0,0.08); border: 1px solid #ddd; }}
+    svg {{ background: #fff; border-radius: 8px; display: block; }}
+    .node circle {{ stroke-width: 2.5px; }}
+    .node text {{ font: 13px 'Segoe UI', sans-serif; paint-order: stroke fill; stroke: #fff; stroke-width: 3px; stroke-linejoin: round; stroke-opacity: 0.85; }}
+    .link {{ fill: none; stroke-opacity: 0.7; stroke-width: 2px; }}
+  </style>
+</head>
+<body>
+  <h1>{header}</h1>
+  <div class="controls">
+    <button onclick="expandAll()">Expand All</button>
+    <button onclick="collapseAll()">Collapse All</button>
+    <button onclick="resetView()">Reset View</button>
+  </div>
+  <div id="tree-container">
+    <svg id="tree-svg" width="{svg_width}" height="{svg_height}"></svg>
+  </div>
+  <script src="https://d3js.org/d3.v7.min.js"></script>
+  <script>
+    const initialJsonData = {data_json};
+    function transformData(d) {{
+      function p(node, parentL1) {{
+        let dn = node.name;
+        if (node.total_count !== undefined && !/\(Total Count: \d+\)$/.test(dn))
+          dn += ` (Total Count: ${{node.total_count}})`;
+        const r = {{ name: dn, originalStageName: parentL1 === "Root" ? node.name : parentL1 }};
+        if (node.children && node.children.length > 0)
+          r.children = node.children.map(c => p(c, parentL1 === "Root" ? node.name : parentL1));
+        return r;
+      }}
+      let rn = d.name;
+      if (d.total_count !== undefined && !/\(Total Count: \d+\)$/.test(rn)) rn += ` (Total Count: ${{d.total_count}})`;
+      return {{ name: rn, originalStageName: "Root", children: (d.children || []).map(c => p(c, "Root")) }};
+    }}
+    const treeData = transformData(initialJsonData);
+    const PALETTE = [
+      ["#3498DB","#2980B9","#AED6F1"],["#2ECC71","#27AE60","#A9DFBF"],
+      ["#E74C3C","#C0392B","#F5B7B1"],["#9B59B6","#8E44AD","#D7BDE2"],
+      ["#F39C12","#D68910","#FAD7A0"],["#1ABC9C","#117864","#A2D9CE"],
+      ["#34495E","#1B2631","#ABB2B9"],["#E67E22","#BA4A00","#F5CBA7"],
+    ];
+    const phaseColors = {{ "Root": {{ fill:"#4A4A4A",stroke:"#333333",collapsedFill:"#6C757D" }}, "Default": {{ fill:"#BDC3C7",stroke:"#95A5A6",collapsedFill:"#ECF0F1" }} }};
+    (initialJsonData.children||[]).forEach((c,i) => {{ const pal=PALETTE[i%PALETTE.length]; phaseColors[c.name]={{ fill:pal[0],stroke:pal[1],collapsedFill:pal[2] }}; }});
+    const levelPalettes = {{
+      0:{{fill:"#4A4A4A",stroke:"#333333",collapsedFill:"#6C757D"}},
+      2:{{fill:"#6ab04c",stroke:"#508a38",collapsedFill:"#a3d391"}},
+      3:{{fill:"#f0932b",stroke:"#d0730f",collapsedFill:"#f6c07e"}},
+      4:{{fill:"#be2edd",stroke:"#a01cb3",collapsedFill:"#e08bf2"}},
+      default:{{fill:"#747d8c",stroke:"#57606f",collapsedFill:"#a4b0be"}}
+    }};
+    const svg = d3.select("#tree-svg");
+    const margin = {{top:40,right:120,bottom:80,left:450}};
+    const duration = 500;
+    let nc = 0;
+    const g = svg.append("g").attr("transform",`translate(${{margin.left}},${{margin.top}})`);
+    const treemap = d3.tree().nodeSize([40,0]);
+    let root = d3.hierarchy(treeData, d=>d.children);
+    root.x0=0; root.y0=0;
+    if (root.children) root.children.forEach(collapse);
+    update(root);
+    function collapse(d) {{ if(d.children){{ d._children=d.children; d._children.forEach(collapse); d.children=null; }} }}
+    function expand(d) {{ if(d._children){{ d.children=d._children; d._children=null; }} if(d.children) d.children.forEach(expand); }}
+    window.expandAll=()=>{{ expand(root); update(root); }};
+    window.collapseAll=()=>{{ if(root.children) root.children.forEach(collapse); update(root); }};
+    window.resetView=()=>{{ if(root.children) root.children.forEach(c=>{{ if(c.children||c._children) collapse(c); }}); update(root); }};
+    function pal(d) {{
+      if (d.depth===0) return levelPalettes[0];
+      if (d.depth===1) return phaseColors[d.data.originalStageName]||phaseColors.Default;
+      return levelPalettes[d.depth]||levelPalettes.default;
+    }}
+    function update(src) {{
+      const td = treemap(root);
+      const nodes = td.descendants(), links = td.descendants().slice(1);
+      const minX = d3.min(nodes,d=>d.x)||0, maxX = d3.max(nodes,d=>d.x)||0;
+      svg.transition().duration(duration/2).attr("height",Math.max(+svg.attr("height"),maxX-minX+margin.top+margin.bottom+100));
+      g.transition().duration(duration/2).attr("transform",`translate(${{margin.left}},${{margin.top-minX+40}})`);
+      nodes.forEach(d=>{{ d.y=d.depth*400; }});
+      const node = g.selectAll('g.node').data(nodes, d=>d.id||(d.id=++nc));
+      const ne = node.enter().append('g')
+        .attr('class','node')
+        .attr('transform',`translate(${{src.y0}},${{src.x0}})`)
+        .style('cursor',d=>(d.children||d._children)?'pointer':'default')
+        .on('click',(e,d)=>{{ if(d.children){{ d._children=d.children; d.children=null; }} else if(d._children){{ d.children=d._children; d._children=null; }} update(d); }});
+      ne.append('circle').attr('r',1e-6);
+      ne.append('text').attr('dy','.35em').attr('x',d=>d.children||d._children?-14:14).attr('text-anchor',d=>d.children||d._children?'end':'start').style("fill-opacity",1e-6);
+      const nu = ne.merge(node);
+      nu.transition().duration(duration).attr('transform',d=>`translate(${{d.y}},${{d.x}})`);
+      nu.select('circle').attr('r',8.5)
+        .style('fill',d=>d._children?pal(d).collapsedFill:d.children?pal(d).fill:"#fff")
+        .style('stroke',d=>pal(d).stroke);
+      nu.select('text').style("fill-opacity",1).text(d=>d.data.name.replace(/\s*\(Total Count: \d+\)$/,''));
+      node.exit().transition().duration(duration).attr('transform',`translate(${{src.y}},${{src.x}})`).remove();
+      const link = g.selectAll('path.link').data(links,d=>d.id);
+      link.enter().insert('path',"g").attr('class','link').attr('d',d=>{{ const o={{x:src.x0,y:src.y0}}; return `M${{o.y}} ${{o.x}} C${{(o.y+o.y)/2}} ${{o.x}},${{(o.y+o.y)/2}} ${{o.x}},${{o.y}} ${{o.x}}`; }})
+        .merge(link).transition().duration(duration).attr('d',d=>`M${{d.y}} ${{d.x}} C${{(d.y+d.parent.y)/2}} ${{d.x}},${{(d.y+d.parent.y)/2}} ${{d.parent.x}},${{d.parent.y}} ${{d.parent.x}}`)
+        .style('stroke',d=>pal(d.parent).stroke);
+      link.exit().transition().duration(duration).attr('d',d=>{{ const o={{x:src.x,y:src.y}}; return `M${{o.y}} ${{o.x}} C${{o.y}} ${{o.x}},${{o.y}} ${{o.x}},${{o.y}} ${{o.x}}`; }}).remove();
+      nodes.forEach(d=>{{ d.x0=d.x; d.y0=d.y; }});
+    }}
+  </script>
+</body>
+</html>"""
+
+
+def to_html(graph_dict: dict, output_path: str, *, project_label: str | None = None) -> str:
+    """Generate D3 collapsible tree HTML. Returns path written."""
+    tree = build_tree(graph_dict, project_label=project_label)
+    title = _html.escape(f"{tree['name']} — CodeGraph file tree")
+    header = _html.escape(f"{tree['name']} — File Tree")
+    data_json = json.dumps(tree, ensure_ascii=False, separators=(",", ":")).replace("</", "<\\/")
+
+    html_content = _HTML_TEMPLATE.format(
+        title=title,
+        header=header,
+        svg_width=6000,
+        svg_height=8000,
+        data_json=data_json,
+    )
+    out = Path(output_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(html_content, encoding="utf-8")
+    return str(out)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "context-mcp-server",
-  "version": "1.0.8",
-  "description": "Persistent AI memory + codebase knowledge graph MCP server. Works across Claude Code, Cursor, Gemini CLI, Codex, Windsurf, VS Code Copilot, Claude.ai, and ChatGPT.",
+  "version": "1.1.1",
+  "description": "Persistent AI memory + codebase knowledge graph MCP server. Works across Claude Code, Cursor, Gemini CLI, Codex, Windsurf, VS Code Copilot, Antigravity IDE, Claude.ai, and ChatGPT.",
   "type": "module",
   "bin": {
     "context-mcp": "./src/index.js",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codegraph-mcp"
-version = "1.0.8"
+version = "1.1.1"
 description = "Codebase knowledge graph MCP server — AST extraction, graph queries, community detection"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -18,6 +18,9 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+leiden = [
+    "graspologic>=3.3",
+]
 treesitter = [
     "tree-sitter>=0.23.0",
     "tree-sitter-python",