fix: preserve Clojure symbol case in graph IDs

Keep Clojure extractor IDs and same-file call lookup case-sensitive, and avoid deduplicating same-file code labels that only differ by case.

Co-authored-by: Codex <noreply@openai.com>

Author: alendit

graphify/dedup.py

@@ -19,6 +19,18 @@ def _norm(label: str) -> str:
     return re.sub(r"[^a-z0-9]+", " ", label.lower()).strip()
 
 
+def _exact_label_groups(nodes: list[dict]) -> list[list[dict]]:
+    """Avoid exact-deduping same-file symbols that differ only by case."""
+    labels = [str(node.get("label", node.get("id", ""))) for node in nodes]
+    if len(set(labels)) <= 1 or len({label.lower() for label in labels}) != 1:
+        return [nodes]
+
+    by_label: dict[str, list[dict]] = defaultdict(list)
+    for node, label in zip(nodes, labels, strict=True):
+        by_label[label].append(node)
+    return [group for group in by_label.values() if len(group) > 1]
+
+
 def _entropy(label: str) -> float:
     """Shannon entropy in bits/char of the normalised label."""
     s = _norm(label)
@@ -185,11 +197,13 @@ def deduplicate_entities(
             sf = node.get("source_file") or ""
             by_file[sf].append(node)
         for file_group in by_file.values():
-            if len(file_group) > 1:
-                winner = _pick_winner(file_group)
-                for node in file_group:
+            if len(file_group) <= 1:
+                continue
+            for exact_group in _exact_label_groups(file_group):
+                winner = _pick_winner(exact_group)
+                for node in exact_group:
                     uf.union(winner["id"], node["id"])
-                exact_merges += len(file_group) - 1
+                exact_merges += len(exact_group) - 1
 
     # ── pass 2: MinHash/LSH + Jaro-Winkler (high-entropy nodes only) ─────────
     candidates: list[dict] = []

graphify/extract.py

@@ -6131,6 +6131,13 @@ def node_text(node) -> str:
     def named_children(node) -> list[object]:
         return [child for child in node.children if getattr(child, "is_named", False)]
 
+    def make_clojure_id(*parts: str) -> str:
+        combined = "_".join(p.strip("_.") for p in parts if p)
+        combined = unicodedata.normalize("NFKC", combined)
+        cleaned = re.sub(r"[^\w]+", "_", combined, flags=re.UNICODE)
+        cleaned = re.sub(r"_+", "_", cleaned)
+        return cleaned.strip("_")
+
     def form_head(node) -> str | None:
         if node.type != "list_lit":
             return None
@@ -6199,7 +6206,7 @@ def add_import_edges(ns_form) -> None:
                     else:
                         continue
                     if module_name:
-                        add_edge(src_nid, _make_id(module_name), "imports_from",
+                        add_edge(src_nid, make_clojure_id(module_name), "imports_from",
                                  module_node.start_point[0] + 1, context="import")
             elif clause_head == ":import":
                 for import_form in clause_children[1:]:
@@ -6214,7 +6221,7 @@ def add_import_edges(ns_form) -> None:
                     imported = import_symbols[1:] or [package]
                     for name in imported:
                         target = f"{package}.{name}" if name != package else package
-                        add_edge(src_nid, _make_id(target), "imports",
+                        add_edge(src_nid, make_clojure_id(target), "imports",
                                  import_form.start_point[0] + 1, context="import")
 
     def add_protocol_methods(protocol_nid: str, protocol_form) -> None:
@@ -6225,7 +6232,7 @@ def add_protocol_methods(protocol_nid: str, protocol_form) -> None:
             if not method_name:
                 continue
             line = child.start_point[0] + 1
-            method_nid = _make_id(protocol_nid, method_name)
+            method_nid = make_clojure_id(protocol_nid, method_name)
             add_node(method_nid, f".{method_name}()", line)
             add_edge(protocol_nid, method_nid, "method", line)
 
@@ -6257,16 +6264,16 @@ def add_definition(form) -> None:
         if head == "defmethod":
             dispatch = node_text(children[2]) if len(children) > 2 else ""
             label = f"{name} {dispatch}".strip()
-            nid = _make_id(stem, name, dispatch)
+            nid = make_clojure_id(stem, name, dispatch)
         elif head in type_heads:
             label = name
-            nid = _make_id(stem, name)
+            nid = make_clojure_id(stem, name)
         elif head in callable_heads or head == "defmulti":
             label = f"{name}()"
-            nid = _make_id(stem, name)
+            nid = make_clojure_id(stem, name)
         else:
             label = name
-            nid = _make_id(stem, name)
+            nid = make_clojure_id(stem, name)
 
         add_node(nid, label, line)
         add_edge(parent_nid(), nid, "contains", line)
@@ -6284,7 +6291,7 @@ def add_definition(form) -> None:
             ns_children = named_children(child)
             if len(ns_children) > 1 and ns_children[1].type == "sym_lit":
                 namespace_name = node_text(ns_children[1])
-                namespace_nid = _make_id(stem, namespace_name)
+                namespace_nid = make_clojure_id(stem, namespace_name)
                 add_node(namespace_nid, namespace_name, ns_children[1].start_point[0] + 1)
                 add_edge(file_nid, namespace_nid, "contains", ns_children[1].start_point[0] + 1)
                 add_import_edges(child)
@@ -6295,7 +6302,7 @@ def add_definition(form) -> None:
     for n in nodes:
         raw = n["label"]
         normalised = raw.strip("()").lstrip(".").split(" ", 1)[0]
-        label_to_nid[normalised.casefold()] = n["id"]
+        label_to_nid[normalised] = n["id"]
 
     seen_call_pairs: set[tuple[str, str]] = set()
 
@@ -6319,7 +6326,7 @@ def walk_calls(node, caller_nid: str) -> None:
             if raw_head:
                 callee_name = callee_from_symbol(raw_head)
                 if callee_name:
-                    tgt_nid = label_to_nid.get(callee_name.casefold())
+                    tgt_nid = label_to_nid.get(callee_name)
                     if tgt_nid and tgt_nid != caller_nid:
                         pair = (caller_nid, tgt_nid)
                         if pair not in seen_call_pairs:

tests/test_languages.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 from pathlib import Path
 import pytest
+from graphify.build import build
 from graphify.extract import (
     extract_java, extract_c, extract_cpp, extract_ruby,
     extract_csharp, extract_kotlin, extract_scala, extract_php,
@@ -905,6 +906,38 @@ def test_clojure_emits_same_file_calls():
     assert any("handle-request" in src and "normalize-name" in tgt for src, tgt in calls)
 
 
+def test_clojure_preserves_case_sensitive_symbols(tmp_path):
+    sample = tmp_path / "case_sensitive.clj"
+    sample.write_text(
+        """(ns sample.case)
+(defn Foo [] :upper)
+(defn foo [] :lower)
+(defn call-upper [] (Foo))
+(defn call-lower [] (foo))
+""",
+        encoding="utf-8",
+    )
+
+    r = extract_clojure(sample)
+
+    assert "error" not in r
+    ids_by_label = {n["label"]: n["id"] for n in r["nodes"]}
+    assert "Foo()" in ids_by_label
+    assert "foo()" in ids_by_label
+    assert ids_by_label["Foo()"] != ids_by_label["foo()"]
+
+    calls = _calls(r)
+    assert ("call-upper()", "Foo()") in calls
+    assert ("call-lower()", "foo()") in calls
+    assert ("call-upper()", "foo()") not in calls
+    assert ("call-lower()", "Foo()") not in calls
+
+    G = build([r])
+    built_labels = [data.get("label") for _, data in G.nodes(data=True)]
+    assert "Foo()" in built_labels
+    assert "foo()" in built_labels
+
+
 def test_clojure_call_edges_have_call_context():
     r = extract_clojure(FIXTURES / "sample.clj")
     call_edges = _edges_with_relation(r, "calls")