chore: import upstream snapshot with attribution

tests/test_wiki.py

@@ -0,0 +1,391 @@
+"""Tests for graphify.wiki — Wikipedia-style article generation."""
+import re
+import urllib.parse
+import pytest
+from pathlib import Path
+import networkx as nx
+from graphify.wiki import to_wiki, _index_md, _community_article, _god_node_article
+
+_MD_LINK = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
+
+
+def _inline_links(text):
+    """Yield (display, decoded_target) for each inline markdown link, skipping
+    external URLs. Targets are URL-decoded so they can be checked against the
+    on-disk filename. (Display text with an escaped `]` isn't matched, but the
+    generated labels used in link position never contain brackets.)"""
+    for display, target in _MD_LINK.findall(text):
+        if "://" in target:
+            continue
+        yield display, urllib.parse.unquote(target)
+
+
+def _make_graph():
+    G = nx.Graph()
+    G.add_node("n1", label="parse", file_type="code", source_file="parser.py", community=0)
+    G.add_node("n2", label="validate", file_type="code", source_file="parser.py", community=0)
+    G.add_node("n3", label="render", file_type="code", source_file="renderer.py", community=1)
+    G.add_node("n4", label="stream", file_type="code", source_file="renderer.py", community=1)
+    G.add_edge("n1", "n2", relation="calls", confidence="EXTRACTED", weight=1.0)
+    G.add_edge("n1", "n3", relation="references", confidence="INFERRED", weight=1.0)
+    G.add_edge("n3", "n4", relation="calls", confidence="EXTRACTED", weight=1.0)
+    return G
+
+
+COMMUNITIES = {0: ["n1", "n2"], 1: ["n3", "n4"]}
+LABELS = {0: "Parsing Layer", 1: "Rendering Layer"}
+COHESION = {0: 0.85, 1: 0.72}
+GOD_NODES = [{"id": "n1", "label": "parse", "degree": 2}]
+
+
+def test_to_wiki_writes_index(tmp_path):
+    G = _make_graph()
+    n = to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, cohesion=COHESION, god_nodes_data=GOD_NODES)
+    assert (tmp_path / "index.md").exists()
+
+
+def test_to_wiki_returns_article_count(tmp_path):
+    G = _make_graph()
+    # 2 communities + 1 god node = 3
+    n = to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, cohesion=COHESION, god_nodes_data=GOD_NODES)
+    assert n == 3
+
+
+def test_to_wiki_community_articles_created(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS)
+    assert (tmp_path / "Parsing_Layer.md").exists()
+    assert (tmp_path / "Rendering_Layer.md").exists()
+
+
+def test_to_wiki_god_node_article_created(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, god_nodes_data=GOD_NODES)
+    assert (tmp_path / "parse.md").exists()
+
+
+def test_index_links_all_communities(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS)
+    index = (tmp_path / "index.md").read_text()
+    assert "[Parsing Layer](Parsing_Layer.md)" in index
+    assert "[Rendering Layer](Rendering_Layer.md)" in index
+
+
+def test_index_lists_god_nodes(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, god_nodes_data=GOD_NODES)
+    index = (tmp_path / "index.md").read_text()
+    assert "[parse](parse.md)" in index
+    assert "2 connections" in index
+
+
+def test_community_article_has_cross_links(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS)
+    parsing = (tmp_path / "Parsing_Layer.md").read_text()
+    # n1 (parsing) references n3 (rendering) → cross-community link
+    assert "[Rendering Layer](Rendering_Layer.md)" in parsing
+
+
+def test_community_article_shows_cohesion(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, cohesion=COHESION)
+    parsing = (tmp_path / "Parsing_Layer.md").read_text()
+    assert "cohesion 0.85" in parsing
+
+
+def test_community_article_has_audit_trail(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS)
+    parsing = (tmp_path / "Parsing_Layer.md").read_text()
+    assert "EXTRACTED" in parsing
+    assert "INFERRED" in parsing
+
+
+def test_god_node_article_has_connections(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, god_nodes_data=GOD_NODES)
+    article = (tmp_path / "parse.md").read_text()
+    # parse's neighbours (validate, render) have no article of their own, so the
+    # connections list shows them as plain text rather than as links.
+    assert "validate" in article and "render" in article
+    assert "[[" not in article
+    assert "](validate.md)" not in article and "](render.md)" not in article
+
+
+def test_god_node_article_links_community(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, god_nodes_data=GOD_NODES)
+    article = (tmp_path / "parse.md").read_text()
+    assert "[Parsing Layer](Parsing_Layer.md)" in article
+
+
+def test_to_wiki_skips_missing_god_node_ids(tmp_path):
+    """God node with bad ID should not crash."""
+    G = _make_graph()
+    bad_gods = [{"id": "nonexistent", "label": "ghost", "degree": 99}]
+    n = to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, god_nodes_data=bad_gods)
+    # 2 communities + 0 god nodes (nonexistent skipped) = 2
+    assert n == 2
+
+
+def test_to_wiki_no_labels_uses_fallback(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path)  # no labels
+    assert (tmp_path / "Community_0.md").exists()
+    assert (tmp_path / "Community_1.md").exists()
+    # fallback "Community N" labels still produce links that resolve to the file
+    targets = [t for _, t in _inline_links((tmp_path / "index.md").read_text())]
+    assert "Community_0.md" in targets and (tmp_path / "Community_0.md").exists()
+
+
+def test_article_navigation_footer(tmp_path):
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS)
+    article = (tmp_path / "Parsing_Layer.md").read_text()
+    assert "[index](index.md)" in article
+
+
+def test_community_article_truncation_notice(tmp_path):
+    """Communities with more than 25 nodes show a truncation notice."""
+    G = nx.Graph()
+    nodes = [f"n{i}" for i in range(30)]
+    for nid in nodes:
+        G.add_node(nid, label=f"concept_{nid}", file_type="code", source_file="a.py", community=0)
+    for i in range(len(nodes) - 1):
+        G.add_edge(nodes[i], nodes[i + 1], relation="calls", confidence="EXTRACTED", weight=1.0)
+    communities = {0: nodes}
+    to_wiki(G, communities, tmp_path, community_labels={0: "Big Community"})
+    article = (tmp_path / "Big_Community.md").read_text()
+    assert "and 5 more nodes" in article
+
+
+# Regression tests for #925 - cross-community links always empty when node attrs lack community
+def test_cross_community_links_without_node_community_attrs(tmp_path):
+    """Cross-community links must work even when nodes have no 'community' attribute (#925)."""
+    G = nx.Graph()
+    G.add_node("n1", label="parse", file_type="code", source_file="parser.py")
+    G.add_node("n2", label="render", file_type="code", source_file="renderer.py")
+    G.add_edge("n1", "n2", relation="references", confidence="INFERRED", weight=1.0)
+    communities = {0: ["n1"], 1: ["n2"]}
+    labels = {0: "Parsing", 1: "Rendering"}
+    to_wiki(G, communities, tmp_path, community_labels=labels)
+    article = (tmp_path / "Parsing.md").read_text()
+    assert "[Rendering](Rendering.md)" in article
+
+
+def test_god_node_article_community_without_node_attr(tmp_path):
+    """God node article must show community name even when node has no 'community' attr (#925)."""
+    G = nx.Graph()
+    G.add_node("n1", label="parse", file_type="code", source_file="parser.py")
+    G.add_node("n2", label="validate", file_type="code", source_file="parser.py")
+    G.add_edge("n1", "n2", relation="calls", confidence="EXTRACTED", weight=1.0)
+    communities = {0: ["n1", "n2"]}
+    labels = {0: "Core Logic"}
+    god_nodes = [{"id": "n1", "label": "parse", "degree": 1}]
+    to_wiki(G, communities, tmp_path, community_labels=labels, god_nodes_data=god_nodes)
+    article = (tmp_path / "parse.md").read_text()
+    assert "[Core Logic](Core_Logic.md)" in article
+
+
+# Regression tests for #936 - stale community node IDs crash to_wiki after dedup/re-extract
+
+def test_to_wiki_drops_stale_community_nodes(tmp_path):
+    """Stale node IDs in communities dict are silently dropped without crash (#936)."""
+    G = _make_graph()
+    # Add a stale ID that exists in communities but not in G
+    communities = {0: ["n1", "n2", "stale_ghost"], 1: ["n3", "n4"]}
+    n = to_wiki(G, communities, tmp_path, community_labels=LABELS)
+    assert n == 2  # both community articles still written
+    article = (tmp_path / "Parsing_Layer.md").read_text()
+    assert "parse" in article
+    assert "stale_ghost" not in article
+
+
+def test_to_wiki_all_stale_raises(tmp_path):
+    """If every community node is stale, raise ValueError with a helpful message (#936)."""
+    G = _make_graph()
+    all_stale = {0: ["ghost1", "ghost2"], 1: ["ghost3"]}
+    with pytest.raises(ValueError, match="stale"):
+        to_wiki(G, all_stale, tmp_path, community_labels=LABELS)
+
+
+def test_to_wiki_stale_nodes_prints_warning(tmp_path, capsys):
+    """Stale node IDs trigger a stderr warning showing the drop count (#936)."""
+    G = _make_graph()
+    communities = {0: ["n1", "stale1", "stale2"], 1: ["n3", "n4"]}
+    to_wiki(G, communities, tmp_path, community_labels=LABELS)
+    err = capsys.readouterr().err
+    assert "2" in err  # dropped count
+    assert "stale" in err.lower()
+
+
+def test_community_article_handles_null_source_file(tmp_path):
+    """source_file=None on a node must not crash sorted() with TypeError (#1016)."""
+    G = nx.Graph()
+    G.add_node("n1", label="parse", file_type="code", source_file=None, community=0)
+    G.add_node("n2", label="validate", file_type="code", source_file="parser.py", community=0)
+    G.add_edge("n1", "n2", relation="calls", confidence="EXTRACTED", weight=1.0)
+    communities = {0: ["n1", "n2"]}
+    labels = {0: "Parsing Layer"}
+    # Must not raise TypeError
+    to_wiki(G, communities, tmp_path, community_labels=labels)
+    assert (tmp_path / "index.md").exists()
+
+
+def test_to_wiki_case_only_distinct_labels_dont_overwrite(tmp_path):
+    """Two community labels differing only by case must each get their own
+    article. The slug-dedup set folds case, so on case-insensitive filesystems
+    (macOS/APFS, Windows/NTFS) the second article gets a numeric suffix instead
+    of silently overwriting the first."""
+    G = nx.Graph()
+    G.add_node("n1", label="parse", file_type="code", source_file="a.py", community=0)
+    G.add_node("n2", label="render", file_type="code", source_file="b.py", community=1)
+    G.add_edge("n1", "n2", relation="calls", confidence="EXTRACTED", weight=1.0)
+    communities = {0: ["n1"], 1: ["n2"]}
+    labels = {0: "Parser", 1: "parser"}
+    n = to_wiki(G, communities, tmp_path, community_labels=labels)
+    articles = [p for p in tmp_path.glob("*.md") if p.name != "index.md"]
+    # both communities survive as separate files on disk (no silent overwrite)
+    assert len(articles) == n == 2, [p.name for p in articles]
+    # filenames are distinct even when compared case-insensitively
+    lowered = [p.stem.lower() for p in articles]
+    assert len(set(lowered)) == len(lowered), [p.name for p in articles]
+
+
+def test_to_wiki_god_node_label_case_collides_with_community(tmp_path):
+    """Community and god-node articles share one slug-dedup set, so a god-node
+    label differing only by case from a community label must still get its own
+    file rather than overwriting the community article."""
+    G = nx.Graph()
+    G.add_node("n1", label="parse", file_type="code", source_file="a.py", community=0)
+    G.add_node("n2", label="run", file_type="code", source_file="b.py", community=0)
+    G.add_edge("n1", "n2", relation="calls", confidence="EXTRACTED", weight=1.0)
+    communities = {0: ["n1", "n2"]}
+    labels = {0: "Parser"}
+    god_nodes = [{"id": "n1", "label": "parser", "degree": 1}]
+    n = to_wiki(G, communities, tmp_path, community_labels=labels, god_nodes_data=god_nodes)
+    articles = [p for p in tmp_path.glob("*.md") if p.name != "index.md"]
+    assert len(articles) == n == 2, [p.name for p in articles]
+    lowered = [p.stem.lower() for p in articles]
+    assert len(set(lowered)) == len(lowered), [p.name for p in articles]
+
+
+# Regression tests for portable wiki links - Obsidian [[wikilinks]] break in
+# every non-Obsidian renderer (VS Code preview, GitHub, GitLab, plain browsers).
+
+
+def test_wiki_emits_no_obsidian_wikilinks(tmp_path):
+    """No generated file may contain Obsidian [[...]] syntax. Those links resolve
+    only inside Obsidian (by note title); everywhere else [[Domain Data Models]]
+    points at a literal `Domain Data Models.md` that doesn't exist."""
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, cohesion=COHESION, god_nodes_data=GOD_NODES)
+    for md in tmp_path.glob("*.md"):
+        assert "[[" not in md.read_text(), md.name
+
+
+def test_wiki_links_resolve_to_real_files(tmp_path):
+    """Every inline markdown link target across the whole wiki must point at a
+    file that actually exists on disk. The display text may keep spaces/special
+    characters, but the target is the URL-encoded slug, so it has to round-trip
+    back to a real filename in any renderer."""
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, cohesion=COHESION, god_nodes_data=GOD_NODES)
+    seen_link = False
+    for md in tmp_path.glob("*.md"):
+        for display, target in _inline_links(md.read_text()):
+            seen_link = True
+            assert (tmp_path / target).exists(), f"{md.name}: [{display}] -> {target} is dead"
+    # guard against the test passing vacuously if links ever stop being emitted
+    assert seen_link, "expected the wiki to contain inline markdown links"
+
+
+def test_wiki_link_display_keeps_label_but_target_is_filename(tmp_path):
+    """The fix's whole point: a link's display text is the human label (with
+    spaces) while its target is the on-disk slug (underscores). This is what
+    [[Domain Data Models]] could never express portably."""
+    G = _make_graph()
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS)
+    index = (tmp_path / "index.md").read_text()
+    assert "[Parsing Layer](Parsing_Layer.md)" in index
+    assert "Parsing Layer.md" not in index  # the broken Obsidian-only target
+
+
+def test_wiki_special_characters_in_label_resolve(tmp_path):
+    """Labels with spaces, &, #, and parentheses must still produce a link whose
+    URL-encoded target decodes back to the real (underscored) filename, so it
+    works in CommonMark renderers and Obsidian alike. # is the dangerous one —
+    left raw in a relative link it would be misread as a fragment."""
+    G = nx.Graph()
+    G.add_node("n1", label="a", file_type="code", source_file="a.py", community=0)
+    G.add_node("n2", label="b", file_type="code", source_file="b.py", community=1)
+    G.add_edge("n1", "n2", relation="references", confidence="INFERRED", weight=1.0)
+    communities = {0: ["n1"], 1: ["n2"]}
+    labels = {0: "C# & Auth (v2)", 1: "Other"}
+    to_wiki(G, communities, tmp_path, community_labels=labels)
+    article = (tmp_path / "Other.md").read_text()
+    # the cross-link to the special-char community resolves to its real file
+    targets = [t for _, t in _inline_links(article)]
+    assert "C#_&_Auth_(v2).md" in targets
+    assert (tmp_path / "C#_&_Auth_(v2).md").exists()
+    # the raw target is fully percent-encoded — no bare ( ) that would terminate
+    # the link early, no bare # that would be misread as a fragment
+    assert "C%23_%26_Auth_%28v2%29.md" in article
+
+
+def test_wiki_link_with_bracketed_label_resolves(tmp_path):
+    """A label containing `[` / `]` (e.g. a generic like `Array[T]`) still
+    produces a resolvable link: the brackets are escaped in the display text so
+    they don't break the markdown, and percent-encoded in the target so it
+    decodes back to the real file. (`_safe_filename` keeps brackets in the slug,
+    so they reach the link target.)"""
+    G = nx.Graph()
+    G.add_node("n1", label="a", file_type="code", source_file="a.py", community=0)
+    G.add_node("n2", label="b", file_type="code", source_file="b.py", community=1)
+    G.add_edge("n1", "n2", relation="references", confidence="INFERRED", weight=1.0)
+    communities = {0: ["n1"], 1: ["n2"]}
+    labels = {0: "Array[T] Models", 1: "Other"}
+    to_wiki(G, communities, tmp_path, community_labels=labels)
+    article = (tmp_path / "Other.md").read_text()
+    assert r"[Array\[T\] Models](Array%5BT%5D_Models.md)" in article
+    assert (tmp_path / "Array[T]_Models.md").exists()
+
+
+def test_wiki_links_to_nodes_without_articles_are_plain_text(tmp_path):
+    """A god node links its neighbours, but only communities and god nodes get
+    article files — neighbours without one must render as plain text, not as a
+    link (dead even inside Obsidian)."""
+    G = _make_graph()
+    # only `parse` (n1) is a god node; its neighbours validate/render are not,
+    # and have no article of their own
+    to_wiki(G, COMMUNITIES, tmp_path, community_labels=LABELS, god_nodes_data=GOD_NODES)
+    article = (tmp_path / "parse.md").read_text()
+    assert "validate" in article and "render" in article
+    # they appear as plain list items, not links
+    assert "- validate" in article and "- render" in article
+    # not wrapped in an Obsidian wikilink (the old form — dead even in Obsidian
+    # since validate/render have no article)...
+    assert "[[validate]]" not in article and "[[render]]" not in article
+    # ...nor in a standard link to a non-existent article file
+    for _, target in _inline_links(article):
+        assert target not in ("validate.md", "render.md"), target
+
+
+def test_wiki_links_use_collision_suffixed_slug(tmp_path):
+    """When two labels collide on disk and the second article gets a numeric
+    suffix (`parser_2.md`), links to it must target the suffixed slug, not the
+    bare label. The resolver records the exact filename each article was written
+    under, so the link target tracks the collision suffix."""
+    G = nx.Graph()
+    G.add_node("n1", label="a", file_type="code", source_file="a.py", community=0)
+    G.add_node("n2", label="b", file_type="code", source_file="b.py", community=1)
+    G.add_edge("n1", "n2", relation="references", confidence="INFERRED", weight=1.0)
+    communities = {0: ["n1"], 1: ["n2"]}
+    labels = {0: "Parser", 1: "parser"}  # collide case-insensitively
+    to_wiki(G, communities, tmp_path, community_labels=labels)
+    index_targets = [t for _, t in _inline_links((tmp_path / "index.md").read_text())]
+    assert "parser_2.md" in index_targets  # link points at the suffixed file...
+    for t in index_targets:
+        assert (tmp_path / t).exists(), t  # ...and every target is a real file