ctxgraph-code 0.5.1__tar.gz → 0.6.1__tar.gz

{ctxgraph_code-0.5.1 → ctxgraph_code-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctxgraph-code
-Version: 0.5.1
+Version: 0.6.1
 Summary: Code knowledge graph for Claude Code. Build a relationship graph of your Python codebase and query it during coding sessions.
 Author: ctxgraph-code contributors
 License: MIT

{ctxgraph_code-0.5.1 → ctxgraph_code-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ctxgraph-code"
-version = "0.5.1"
+version = "0.6.1"
 description = "Code knowledge graph for Claude Code. Build a relationship graph of your Python codebase and query it during coding sessions."
 readme = "README.md"
 license = {text = "MIT"}

{ctxgraph_code-0.5.1 → ctxgraph_code-0.6.1}/src/ctxgraph_code/cli.py

@@ -254,24 +254,22 @@ def _write_slash_command(slash_path: Path, path: Path):
 
 SLASH_COMMAND_TEMPLATE = """# ctxgraph-code: Code Relationship Graph
 
-**First time in this project?** Tell the user to run `ctxgraph-code setup` in their terminal.
-
-**Graph needs refresh?** Tell the user to run `ctxgraph-code build`.
-
 **Available graphs:** {available}
 
 **Commands:**
-- `ctxgraph-code query "terms"` -- Find relevant files, classes, and functions
-- `ctxgraph-code probe "question"` -- Search graph and read matching source code inline
-- `ctxgraph-code deps <path>` -- Show what a file imports and what calls it
-- `ctxgraph-code usedby <path>` -- Show what depends on a file
-- `ctxgraph-code overview --dir <name>` -- Show project structure for a specific graph
-- `ctxgraph-code symbols <path>` -- List classes/functions defined in a file
-- `ctxgraph-code context "task"` -- Generate a focused context summary
-- `ctxgraph-code view --dir <name>` -- Visualize a graph interactively
-
-**Tip:** Use `--dir <name>` to scope queries to a per-directory graph.
-When passing a file path like `auth/login.py`, the correct graph is auto-detected.
+- `ctxgraph-code query "terms"` -- Files, classes, functions
+- `ctxgraph-code probe "question"` -- Search + read source inline
+- `ctxgraph-code deps <path>` -- Dependencies of a file
+- `ctxgraph-code usedby <path>` -- What depends on a file
+- `ctxgraph-code overview --dir <name>` -- Project structure
+- `ctxgraph-code symbols <path>` -- Classes/functions in a file
+- `ctxgraph-code context "task"` -- Focused context summary
+- `ctxgraph-code subgraph "task"` -- Focused subgraph with source
+- `ctxgraph-code diff` -- Files changed since build
+- `ctxgraph-code mermaid --type classDiagram` -- Mermaid diagram
+- `ctxgraph-code view --dir <name>` -- Interactive D3.js graph
+
+Use `--dir <name>` to scope queries. File paths auto-detect the graph dir.
 """
 
 
@@ -386,13 +384,13 @@ def _build_dirs_parallel(path, exts, user_patterns, top_dirs, graphs_dir, jobs,
                 edges = stats.get("total_edges", 0)
                 t = stats.get("elapsed_seconds", 0)
                 console.print(
-                    f"  [green]✔[/green] {label}/ "
+                    f"  [green]OK[/green] {label}/ "
                     f"({files} files, {nodes} nodes, {edges} edges, {t}s)"
                 )
             except Exception as e:
                 results.append((label, str(e)))
                 err_count += 1
-                console.print(f"  [red]✘[/red] {label}/ ([red]{e}[/red])")
+                console.print(f"  [red]FAIL[/red] {label}/ ([red]{e}[/red])")
 
         elapsed_total = time.time() - _build_progress_start
         if err_count:
@@ -819,7 +817,7 @@ def setup(
     )
 
 
-@app.command(name="build-status")
+@app.command(name="build-status")
 def build_status(
     repo_path: Optional[str] = typer.Option(
         None, "--repo", "-r", help="Repository path"
@@ -1105,10 +1103,300 @@ def version():
     try:
         ver = _v("ctxgraph-code")
     except Exception:
-        ver = "0.5.0"
+        ver = "0.6.1"
     console.print(f"ctxgraph-code version [bold]{ver}[/bold]")
 
 
+@app.command()
+def mermaid(
+    repo_path: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository path"
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Save Mermaid output to file"
+    ),
+    max_nodes: int = typer.Option(
+        50, "--max-nodes", "-n", help="Maximum nodes in diagram"
+    ),
+    dir_name: Optional[str] = typer.Option(
+        None, "--dir", "-d", help="Directory graph to use"
+    ),
+    diagram_type: str = typer.Argument(
+        "classDiagram", help="Diagram type: classDiagram, flowchart, sequence"
+    ),
+):
+    """Export the graph as a Mermaid diagram.
+
+    Supported diagram types: classDiagram, flowchart, sequence.
+    Outputs to console by default, or to a file with --output.
+    """
+    path = Path(repo_path).resolve() if repo_path else Path.cwd()
+    storage = _resolve_storage(path, dir_name=dir_name)
+
+    from ctxgraph_code.render.mermaid import MermaidError, render_mermaid
+
+    try:
+        result = render_mermaid(
+            storage,
+            output_type=diagram_type,
+            max_nodes=max_nodes,
+        )
+    except MermaidError as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit(1)
+
+    if output:
+        out_path = Path(output)
+        out_path.write_text(result, encoding="utf-8")
+        console.print(f"[green]Mermaid diagram saved to [bold]{out_path}[/bold][/green]")
+    else:
+        console.print(result)
+
+
+@app.command()
+def subgraph(
+    query: str = typer.Argument(..., help="Task description"),
+    repo_path: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository path"
+    ),
+    max_nodes: int = typer.Option(
+        10, "--max-nodes", "-n", help="Maximum nodes in subgraph"
+    ),
+    dir_name: Optional[str] = typer.Option(
+        None, "--dir", "-d", help="Directory graph to query"
+    ),
+):
+    """Extract a focused subgraph relevant to a task description.
+
+    Returns matching nodes, their relationships, and inline source code
+    for a compact context window.
+    """
+    import hashlib
+
+    path = Path(repo_path).resolve() if repo_path else Path.cwd()
+    storage = _resolve_storage(path, dir_name=dir_name)
+
+    results = search_relevant_nodes(storage, query, max_nodes=max_nodes)
+    if not results:
+        console.print("[yellow]No relevant nodes found for subgraph.[/yellow]")
+        raise typer.Exit()
+
+    matched_ids = {n.id for n, _ in results}
+    edge_ids: set[str] = set()
+    edges = storage.get_edges_for_nodes(matched_ids)
+    for e in edges:
+        if e.source_id in matched_ids:
+            edge_ids.add(e.target_id)
+        if e.target_id in matched_ids:
+            edge_ids.add(e.source_id)
+
+    all_ids = matched_ids | edge_ids
+    node_map: dict[str, object] = {}
+    for nid in all_ids:
+        n = storage.get_node(nid)
+        if n:
+            node_map[nid] = n
+
+    file_nodes_in_subgraph = {
+        n for n in node_map.values()
+        if hasattr(n, 'type') and n.type == "file"
+    }
+
+    lines = [
+        f"Subgraph for: {query}",
+        f"Nodes: {len(matched_ids)} seed + {len(edge_ids)} related = {len(all_ids)} total",
+        "",
+    ]
+
+    # Group by file
+    file_groups: dict[str, list] = {}
+    for n in sorted(node_map.values(), key=lambda x: x.path or ""):
+        fp = getattr(n, 'path', None) or ""
+        file_groups.setdefault(fp, []).append(n)
+
+    for fp, nodes in sorted(file_groups.items()):
+        file_node = next((n for n in nodes if n.type == "file"), None)
+        if file_node:
+            tag = "F"
+            lines.append(f"  [{tag}] [bold]{file_node.name}[/bold] [blue]{file_node.path or '-'}[/blue]")
+            if file_node.summary:
+                lines.append(f"      {file_node.summary}")
+        symbols = [n for n in nodes if n.type in ("class", "function")]
+        if symbols:
+            for s in symbols:
+                tag = "C" if s.type == "class" else "M"
+                lines.append(f"      [{tag}] {s.name} (line {s.lineno})")
+                if s.summary:
+                    lines.append(f"          {s.summary}")
+
+    if edges:
+        lines.append("")
+        lines.append("  Relationships:")
+        for e in edges[:15]:
+            src = node_map.get(e.source_id)
+            tgt = node_map.get(e.target_id)
+            src_name = src.name if src else e.source_id
+            tgt_name = tgt.name if tgt else e.target_id
+            lines.append(f"    {src_name} --[{e.relation}]--> {tgt_name}")
+
+    # Inline source for each file node
+    lines.append("")
+    for n in sorted(file_nodes_in_subgraph, key=lambda x: x.path or ""):
+        fp = path / n.path if n.path else None
+        if fp and fp.is_file():
+            try:
+                code = fp.read_text(encoding="utf-8", errors="replace")
+                lines.append(f"  === {n.path} ===")
+                snippet = code.splitlines()[:60]
+                lines.extend(snippet)
+                if len(code.splitlines()) > 60:
+                    lines.append(f"... ({len(code.splitlines()) - 60} more lines)")
+                lines.append("")
+            except OSError:
+                pass
+
+    console.print("\n".join(lines))
+
+
+@app.command()
+def diff(
+    repo_path: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository path"
+    ),
+    dir_name: Optional[str] = typer.Option(
+        None, "--dir", "-d", help="Directory graph to compare"
+    ),
+    ref_branch: Optional[str] = typer.Option(
+        None, "--ref", help="Git reference/branch to diff against (requires git)"
+    ),
+):
+    """Compare the graph with the filesystem.
+
+    Shows files that have been added, removed, or changed since the
+    graph was built. Use --ref for a git-aware diff against a branch.
+    """
+    import hashlib
+    import json as j
+
+    path = Path(repo_path).resolve() if repo_path else Path.cwd()
+    storage = _resolve_storage(path, dir_name=dir_name)
+
+    new_files: list[str] = []
+    removed_files: list[str] = []
+    changed_files: list[str] = []
+
+    graph_paths = set(storage.get_file_paths())
+    hashes_json = storage.get_metadata("content_hashes")
+    stored_hashes: dict[str, str] = {}
+    if hashes_json:
+        try:
+            stored_hashes = j.loads(hashes_json)
+        except (j.JSONDecodeError, OSError):
+            pass
+
+    if ref_branch:
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["git", "diff", "--name-only", ref_branch],
+                capture_output=True, text=True, check=False, cwd=str(path),
+            )
+            if result.returncode == 0:
+                git_files = set(result.stdout.strip().splitlines()) if result.stdout.strip() else set()
+                for gf in git_files:
+                    if gf not in graph_paths:
+                        new_files.append(gf)
+                for gp in graph_paths:
+                    if gp not in git_files:
+                        removed_files.append(gp)
+                # Changed files = git diff --name-only from HEAD
+                head_result = subprocess.run(
+                    ["git", "diff", "--name-only", "HEAD"],
+                    capture_output=True, text=True, check=False, cwd=str(path),
+                )
+                if head_result.returncode == 0:
+                    changed_files = [f for f in head_result.stdout.strip().splitlines() if f in graph_paths]
+            else:
+                console.print(f"[red]git diff failed: {result.stderr.strip()}[/red]")
+                console.print("[yellow]Falling back to filesystem comparison...[/yellow]")
+                ref_branch = None
+        except FileNotFoundError:
+            console.print("[yellow]Git not found. Falling back to filesystem comparison...[/yellow]")
+            ref_branch = None
+
+    if not ref_branch:
+        for gp in graph_paths:
+            fp = path / gp
+            if not fp.is_file():
+                removed_files.append(gp)
+
+        src_extensions = {".py", ".js", ".ts", ".tsx", ".go", ".rs", ".c", ".h", ".cpp", ".java", ".rb", ".kt", ".swift"}
+        for root, _dirs, files in os.walk(path):
+            _dirs[:] = [d for d in _dirs if not d.startswith(".") and d not in ("node_modules", "venv", ".venv", "env", "dist", "build", "__pycache__")]
+            for f in files:
+                ext = os.path.splitext(f)[1].lower()
+                if ext not in src_extensions:
+                    continue
+                rel_path = os.path.relpath(os.path.join(root, f), path).replace("\\", "/")
+                if rel_path not in graph_paths:
+                    new_files.append(rel_path)
+
+        # Content hash comparison for changed detection
+        if stored_hashes:
+            for rel_path, stored_hash in stored_hashes.items():
+                fp = path / rel_path
+                if fp.is_file():
+                    try:
+                        actual = hashlib.sha256(
+                            fp.read_text(encoding="utf-8", errors="replace")
+                            .encode("utf-8")
+                        ).hexdigest()
+                        if actual != stored_hash:
+                            changed_files.append(rel_path)
+                    except OSError:
+                        changed_files.append(rel_path)
+
+    lines = ["Graph vs Filesystem Diff", ""]
+    if new_files:
+        lines.append(f"  [green]+ {len(new_files)} new file(s):[/green]")
+        for f in sorted(new_files)[:10]:
+            lines.append(f"    + {f}")
+        if len(new_files) > 10:
+            lines.append(f"    ... and {len(new_files) - 10} more")
+    else:
+        lines.append("  [green]+ No new files[/green]")
+
+    if removed_files:
+        lines.append(f"")
+        lines.append(f"  [red]- {len(removed_files)} removed file(s):[/red]")
+        for f in sorted(removed_files)[:10]:
+            lines.append(f"    - {f}")
+        if len(removed_files) > 10:
+            lines.append(f"    ... and {len(removed_files) - 10} more")
+    else:
+        lines.append(f"")
+        lines.append("  [red]- No removed files[/red]")
+
+    if changed_files:
+        lines.append(f"")
+        lines.append(f"  [yellow]~ {len(changed_files)} changed file(s):[/yellow]")
+        for f in sorted(changed_files)[:10]:
+            lines.append(f"    ~ {f}")
+        if len(changed_files) > 10:
+            lines.append(f"    ... and {len(changed_files) - 10} more")
+    else:
+        lines.append(f"")
+        lines.append("  [yellow]~ No changed files[/yellow]")
+
+    lines.append("")
+    if new_files or removed_files or changed_files:
+        lines.append("[yellow]Run [bold]ctxgraph-code build --incremental[/bold] to update the graph.[/yellow]")
+    else:
+        lines.append("[green]Graph is up to date with the filesystem.[/green]")
+
+    console.print("\n".join(lines))
+
+
 if __name__ == "__main__":
     app()
 

{ctxgraph_code-0.5.1 → ctxgraph_code-0.6.1}/src/ctxgraph_code/config/hooks.py

@@ -79,8 +79,6 @@ def uninstall_hooks(project_path: Path, local: bool = False) -> bool:
 
 
 def compute_hint_summary(repo_path: Path) -> Optional[str]:
-    import hashlib
-
     avail = get_available_graphs(repo_path)
     if not avail["_combined"] and not avail["dirs"]:
         return None
@@ -100,8 +98,6 @@ def compute_hint_summary(repo_path: Path) -> Optional[str]:
         total_edges = stats.get("edges", 0)
         types = stats.get("types", {})
 
-        top_files = _get_top_files(storage, 5)
-
         file_count = types.get("file", 0)
         class_count = types.get("class", 0)
         func_count = types.get("function", 0)
@@ -112,54 +108,11 @@ def compute_hint_summary(repo_path: Path) -> Optional[str]:
         ]
         if file_count:
             lines.append(f"Files: {file_count} | Classes: {class_count} | Functions: {func_count}.")
-        if top_files:
-            lines.append(f"Key files: {', '.join(top_files)}.")
-
-        # ── Tamper detection ──────────────────────────────────────
-        hashes_json = storage.get_metadata("content_hashes")
-        tampered: int = 0
-        if hashes_json:
-            try:
-                stored_hashes = json.loads(hashes_json)
-                for rel_path, stored_hash in stored_hashes.items():
-                    fp = repo_path / rel_path
-                    if not fp.is_file():
-                        tampered += 1
-                        continue
-                    try:
-                        actual = hashlib.sha256(
-                            fp.read_text(encoding="utf-8", errors="replace")
-                            .encode("utf-8")
-                        ).hexdigest()
-                        if actual != stored_hash:
-                            tampered += 1
-                    except OSError:
-                        tampered += 1
-            except (json.JSONDecodeError, OSError):
-                pass
-        if tampered:
-            lines.append(
-                f"Warning: {tampered} file(s) have changed since graph was built. "
-                "Run `ctxgraph-code build --incremental` to update."
-            )
 
         lines.append(
-            "Use `ctxgraph-code probe \"<question>\"` to search or "
-            "`/ctxgraph-code` for help."
+            "Use `ctxgraph-code probe` or `/ctxgraph-code` for help."
         )
 
         return "\n".join(lines)
     finally:
         storage.close()
-
-
-def _get_top_files(storage, limit: int = 5) -> list[str]:
-    try:
-        rows = storage.conn.execute(
-            "SELECT path FROM nodes WHERE type = 'file' AND path IS NOT NULL "
-            "ORDER BY size_bytes DESC LIMIT ?",
-            (limit,),
-        ).fetchall()
-        return [r[0] for r in rows if r[0]]
-    except Exception:
-        return []

{ctxgraph_code-0.5.1 → ctxgraph_code-0.6.1}/src/ctxgraph_code/graph/storage.py

@@ -224,6 +224,42 @@ class Storage:
         )
         self.conn.commit()
 
+    def get_nodes_by_file_path(self, file_path: str) -> list[Node]:
+        rows = self.conn.execute(
+            "SELECT * FROM nodes WHERE path = ?", (file_path,)
+        ).fetchall()
+        return [
+            Node(
+                id=r["id"],
+                type=r["type"],
+                name=r["name"],
+                path=r["path"],
+                parent_id=r["parent_id"],
+                summary=r["summary"],
+                importance=r["importance"],
+                size_bytes=r["size_bytes"],
+                lineno=r["lineno"],
+            )
+            for r in rows
+        ]
+
+    def get_file_paths(self) -> list[str]:
+        rows = self.conn.execute(
+            "SELECT DISTINCT path FROM nodes WHERE type = 'file' AND path IS NOT NULL"
+        ).fetchall()
+        return [r[0] for r in rows]
+
+    def get_content_hash(self, file_path: str) -> Optional[str]:
+        hashes_json = self.get_metadata("content_hashes")
+        if not hashes_json:
+            return None
+        try:
+            import json
+            stored = json.loads(hashes_json)
+            return stored.get(file_path)
+        except (json.JSONDecodeError, OSError):
+            return None
+
     def save_metadata(self, key: str, value: str):
         self.conn.execute(
             "INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)",

ctxgraph_code-0.6.1/src/ctxgraph_code/render/__init__.py

@@ -0,0 +1,20 @@
+from ctxgraph_code.render._text import (
+    render_context,
+    render_deps,
+    render_overview,
+    render_symbols,
+    render_treeview,
+    render_usedby,
+)
+
+from ctxgraph_code.render.mermaid import render_mermaid as render_mermaid
+
+__all__ = [
+    "render_context",
+    "render_deps",
+    "render_overview",
+    "render_symbols",
+    "render_treeview",
+    "render_usedby",
+    "render_mermaid",
+]

ctxgraph_code-0.6.1/src/ctxgraph_code/render/mermaid.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from ctxgraph_code.graph.storage import Storage
+
+
+class MermaidError(Exception):
+    pass
+
+
+def render_mermaid(
+    storage: Storage,
+    output_type: str = "classDiagram",
+    max_nodes: int = 50,
+) -> str:
+    output_type = output_type or "classDiagram"
+    supported = {"classDiagram", "flowchart", "sequence"}
+    if output_type not in supported:
+        raise MermaidError(
+            f"Unsupported diagram type '{output_type}'. "
+            f"Choose from: {', '.join(sorted(supported))}"
+        )
+
+    all_nodes = storage.get_all_nodes()
+    all_edges = storage.get_all_edges()
+
+    if output_type == "classDiagram":
+        return _render_class_diagram(all_nodes, all_edges, max_nodes)
+    elif output_type == "flowchart":
+        return _render_flowchart(all_nodes, all_edges, max_nodes)
+    elif output_type == "sequence":
+        return _render_sequence(all_nodes, all_edges, max_nodes)
+    return ""
+
+
+def _safe_id(name: str) -> str:
+    safe = "".join(c if c.isalnum() or c == "_" else "_" for c in name)
+    if safe and safe[0].isdigit():
+        safe = "n" + safe
+    return safe or "node"
+
+
+def _render_class_diagram(nodes: list, edges: list, max_nodes: int) -> str:
+    lines = ["classDiagram"]
+    added = 0
+
+    class_nodes = [n for n in nodes if n.type == "class"]
+    file_nodes = [n for n in nodes if n.type == "file"]
+
+    for cls in class_nodes[:max_nodes]:
+        nid = _safe_id(cls.name)
+        lines.append(f"    class {nid} {{")
+        if cls.summary:
+            lines.append(f"        +{cls.summary}")
+        lines.append("    }")
+        added += 1
+        if added >= max_nodes:
+            break
+
+    if added < max_nodes:
+        remaining = max_nodes - added
+        for f in file_nodes[:remaining]:
+            nid = _safe_id(f.name)
+            label = f.path or f.name
+            lines.append(f"    class {nid} {{")
+            lines.append(f"        +File: {label}")
+            if f.summary:
+                lines.append(f"        +{f.summary}")
+            lines.append("    }")
+
+    inheritance_edges = [e for e in edges if e.relation == "inherits"]
+    for e in inheritance_edges:
+        src_name = _find_node_name(nodes, e.source_id)
+        tgt_name = _find_node_name(nodes, e.target_id)
+        if src_name and tgt_name:
+            lines.append(f"    {_safe_id(src_name)} --|> {_safe_id(tgt_name)}")
+
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _render_flowchart(nodes: list, edges: list, max_nodes: int) -> str:
+    lines = ["flowchart TD"]
+    node_map = {n.id: n for n in nodes}
+    shown: set[str] = set()
+
+    sorted_edges = sorted(edges, key=lambda e: e.weight or 1.0, reverse=True)
+    for e in sorted_edges[:max_nodes * 2]:
+        src = node_map.get(e.source_id)
+        tgt = node_map.get(e.target_id)
+        if not src or not tgt:
+            continue
+        for n in (src, tgt):
+            if n.id not in shown and len(shown) < max_nodes:
+                nid = _safe_id(n.name)
+                label = n.path or n.name
+                lines.append(f"    {nid}[\"{label}\"]")
+                shown.add(n.id)
+        if src.id in shown and tgt.id in shown:
+            src_id = _safe_id(src.name)
+            tgt_id = _safe_id(tgt.name)
+            rel = e.relation or "link"
+            lines.append(f"    {src_id} -->|{rel}| {tgt_id}")
+
+    if not shown and nodes:
+        for n in nodes[:max_nodes]:
+            nid = _safe_id(n.name)
+            label = n.path or n.name
+            lines.append(f"    {nid}[\"{label}\"]")
+
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _render_sequence(nodes: list, edges: list, max_nodes: int) -> str:
+    lines = ["sequenceDiagram"]
+    participants: set[str] = set()
+    node_map = {n.id: n for n in nodes}
+
+    sorted_edges = sorted(edges, key=lambda e: e.weight or 1.0, reverse=True)
+    for e in sorted_edges[:max_nodes * 2]:
+        src = node_map.get(e.source_id)
+        tgt = node_map.get(e.target_id)
+        if not src or not tgt:
+            continue
+        for label, n in [("", src), ("", tgt)]:
+            if n.id not in participants:
+                safe = _safe_id(n.name)
+                display = n.path or n.name
+                lines.append(f"    participant {safe} as \"{display}\"")
+                participants.add(n.id)
+        src_safe = _safe_id(src.name)
+        tgt_safe = _safe_id(tgt.name)
+        rel = e.relation or "calls"
+        lines.append(f"    {src_safe}->>+{tgt_safe}: {rel}")
+
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _find_node_name(nodes: list, node_id: str) -> Optional[str]:
+    for n in nodes:
+        if n.id == node_id:
+            return n.name
+    return None

{ctxgraph_code-0.5.1 → ctxgraph_code-0.6.1}/src/ctxgraph_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctxgraph-code
-Version: 0.5.1
+Version: 0.6.1
 Summary: Code knowledge graph for Claude Code. Build a relationship graph of your Python codebase and query it during coding sessions.
 Author: ctxgraph-code contributors
 License: MIT

{ctxgraph_code-0.5.1 → ctxgraph_code-0.6.1}/src/ctxgraph_code.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ pyproject.toml
 src/ctxgraph_code/__init__.py
 src/ctxgraph_code/__main__.py
 src/ctxgraph_code/cli.py
-src/ctxgraph_code/render.py
 src/ctxgraph_code.egg-info/PKG-INFO
 src/ctxgraph_code.egg-info/SOURCES.txt
 src/ctxgraph_code.egg-info/dependency_links.txt
@@ -31,5 +30,8 @@ src/ctxgraph_code/graph/builder.py
 src/ctxgraph_code/graph/models.py
 src/ctxgraph_code/graph/query.py
 src/ctxgraph_code/graph/storage.py
+src/ctxgraph_code/render/__init__.py
+src/ctxgraph_code/render/_text.py
+src/ctxgraph_code/render/mermaid.py
 src/ctxgraph_code/view/__init__.py
 src/ctxgraph_code/view/visualizer.py