From 224c87ce9363dcaad07e388307a47b1af77b2b5c Mon Sep 17 00:00:00 2001
From: Areg Noya <aaa7661516@gmail.com>
Date: Sat, 11 Apr 2026 09:43:39 -0700
Subject: [PATCH] fix: connect graphify Obsidian output into a single component
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two bugs caused /graphify output to form disconnected components when
dropped into an Obsidian vault:

1. `safe_name()` in `export.py` (both `to_obsidian` and `to_canvas`) did
   not strip trailing `.md`/`.mdx`/`.markdown` from the label before the
   caller appended the file extension. Nodes labelled after markdown
   sources (e.g. `CLAUDE.md`, `Guidelines.md`) produced filenames like
   `CLAUDE.md.md` while their incoming `[[CLAUDE.md]]` wikilinks
   resolved to the non-existent `CLAUDE.md` file. Every such link broke.

2. `report.py`'s `generate()` emitted community headings as plain prose
   (`### Community 15 - "Haptics"`) with zero wikilinks. Once the
   generated `GRAPH_REPORT.md` was copied into a vault as
   `<proj>-graph-report.md`, the entire community subgraph became
   unreachable from the report — the whole project cluster split off
   into a disconnected component.

On one real vault (4549 notes across six graphify projects) these two
bugs produced 52 connected components with ~21% of nodes stranded in
51 islands. After the fixes, re-running the report generator and
regenerating the Obsidian export collapses the graph back to 1
component with 100% of nodes reachable from `master_index.md`.

Fixes:

- `export.py`: both `safe_name()` helpers now strip trailing Markdown
  extensions (`.md`, `.mdx`, `.markdown`, case-insensitive) after
  removing Obsidian-unsafe chars. Idempotent with the existing
  newline-stripping and sanitization.

- `report.py`: added a module-level `_safe_community_name()` that
  mirrors `export.safe_name` so hub filenames and report links stay
  in sync. Inserted a `## Community Hubs (Navigation)` bullet list
  right after `## Summary` that emits
  `[[_COMMUNITY_<safe>|<label>]]` for every community. Upgraded each
  `### Community N` heading to embed the same wikilink so either
  entry point (nav block or community walkthrough) reaches the hub.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 graphify/export.py | 19 +++++++++++++++++--
 graphify/report.py | 34 +++++++++++++++++++++++++++++++++-
 2 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/graphify/export.py b/graphify/export.py
index d35edafc2c..274e31e0ef 100644
--- a/graphify/export.py
+++ b/graphify/export.py
@@ -467,7 +467,15 @@ def to_obsidian(
     # Map node_id → safe filename so wikilinks stay consistent.
     # Deduplicate: if two nodes produce the same filename, append a numeric suffix.
     def safe_name(label: str) -> str:
-        return re.sub(r'[\\/*?:"<>|#^[\]]', "", label.replace("\r\n", " ").replace("\r", " ").replace("\n", " ")).strip() or "unnamed"
+        cleaned = re.sub(
+            r'[\\/*?:"<>|#^[\]]',
+            "",
+            label.replace("\r\n", " ").replace("\r", " ").replace("\n", " "),
+        ).strip()
+        # Strip trailing Markdown extensions so filenames don't collide as foo.md.md
+        # when the node label is itself a markdown filename (e.g. "CLAUDE.md").
+        cleaned = re.sub(r"\.(md|mdx|markdown)$", "", cleaned, flags=re.IGNORECASE)
+        return cleaned or "unnamed"
 
     node_filename: dict[str, str] = {}
     seen_names: dict[str, int] = {}
@@ -703,7 +711,14 @@ def to_canvas(
     CANVAS_COLORS = ["1", "2", "3", "4", "5", "6"]  # red, orange, yellow, green, cyan, purple
 
     def safe_name(label: str) -> str:
-        return re.sub(r'[\\/*?:"<>|#^[\]]', "", label.replace("\r\n", " ").replace("\r", " ").replace("\n", " ")).strip() or "unnamed"
+        cleaned = re.sub(
+            r'[\\/*?:"<>|#^[\]]',
+            "",
+            label.replace("\r\n", " ").replace("\r", " ").replace("\n", " "),
+        ).strip()
+        # Strip trailing Markdown extensions so filenames don't collide as foo.md.md.
+        cleaned = re.sub(r"\.(md|mdx|markdown)$", "", cleaned, flags=re.IGNORECASE)
+        return cleaned or "unnamed"
 
     # Build node_filenames if not provided (same dedup logic as to_obsidian)
     if node_filenames is None:
diff --git a/graphify/report.py b/graphify/report.py
index 91f331cc3b..9cdf538a3e 100644
--- a/graphify/report.py
+++ b/graphify/report.py
@@ -1,9 +1,26 @@
 # generate GRAPH_REPORT.md - the human-readable audit trail
 from __future__ import annotations
+import re
 from datetime import date
 import networkx as nx
 
 
+def _safe_community_name(label: str) -> str:
+    """Mirror of export.safe_name so community hub filenames and report wikilinks match.
+
+    Strips Obsidian-unsafe filename chars and trailing Markdown extensions so a
+    community labelled e.g. "CLAUDE.md" produces the same hub filename in both
+    the Obsidian vault export and the report's [[_COMMUNITY_*]] navigation links.
+    """
+    cleaned = re.sub(
+        r'[\\/*?:"<>|#^[\]]',
+        "",
+        label.replace("\r\n", " ").replace("\r", " ").replace("\n", " "),
+    ).strip()
+    cleaned = re.sub(r"\.(md|mdx|markdown)$", "", cleaned, flags=re.IGNORECASE)
+    return cleaned or "unnamed"
+
+
 def generate(
     G: nx.Graph,
     communities: dict[int, list[str]],
@@ -48,6 +65,20 @@ def generate(
         f"- Extraction: {ext_pct}% EXTRACTED · {inf_pct}% INFERRED · {amb_pct}% AMBIGUOUS"
         + (f" · INFERRED: {len(inf_edges)} edges (avg confidence: {inf_avg})" if inf_avg is not None else ""),
         f"- Token cost: {token_cost.get('input', 0):,} input · {token_cost.get('output', 0):,} output",
+    ]
+
+    # Navigation block — emit [[_COMMUNITY_<safe>|<label>]] for every community
+    # so the report is never a dead-end when dropped into an Obsidian vault.
+    # Without these links the whole community subgraph is unreachable from the
+    # graph-report and forms a disconnected component in the vault graph.
+    if communities:
+        lines += ["", "## Community Hubs (Navigation)"]
+        for cid in communities:
+            label = community_labels.get(cid, f"Community {cid}")
+            safe = _safe_community_name(label)
+            lines.append(f"- [[_COMMUNITY_{safe}|{label}]]")
+
+    lines += [
         "",
         "## God Nodes (most connected - your core abstractions)",
     ]
@@ -89,13 +120,14 @@ def generate(
     for cid, nodes in communities.items():
         label = community_labels.get(cid, f"Community {cid}")
         score = cohesion_scores.get(cid, 0.0)
+        safe = _safe_community_name(label)
         # Filter method/function stubs from display - they're structural noise
         real_nodes = [n for n in nodes if not _ifn(G, n)]
         display = [G.nodes[n].get("label", n) for n in real_nodes[:8]]
         suffix = f" (+{len(real_nodes)-8} more)" if len(real_nodes) > 8 else ""
         lines += [
             "",
-            f"### Community {cid} - \"{label}\"",
+            f"### Community {cid} - [[_COMMUNITY_{safe}|{label}]]",
             f"Cohesion: {score}",
             f"Nodes ({len(real_nodes)}): {', '.join(display)}{suffix}",
         ]