graphifyy 0.9.77__tar.gz → 0.9.78__tar.gz

{graphifyy-0.9.77/graphifyy.egg-info → graphifyy-0.9.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphifyy
-Version: 0.9.77
+Version: 0.9.78
 Summary: AI coding assistant skill (Claude Code, CodeBuddy, Codex, OpenCode, Kilo Code, Cursor, Gemini CLI, Aider, OpenClaw, Factory Droid, Trae, Hermes, Kiro, Pi, Devin CLI, Google Antigravity) - turn any folder of code, docs, papers, images, or videos into a queryable knowledge graph
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://graphify.com
@@ -219,6 +219,10 @@ graphify-out/
 └── graph.json       the full graph — query it anytime without re-reading your files
 ```
 
+The persisted graph includes `graph.schema_version` so integrations can detect
+incompatible format changes, plus `graph.graphify_version` identifying the
+Graphify release that produced it.
+
 **Works in** Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, and 15+ more — [pick your platform](#install).
 
 ---

{graphifyy-0.9.77 → graphifyy-0.9.78}/README.md

@@ -68,6 +68,10 @@ graphify-out/
 └── graph.json       the full graph — query it anytime without re-reading your files
 ```
 
+The persisted graph includes `graph.schema_version` so integrations can detect
+incompatible format changes, plus `graph.graphify_version` identifying the
+Graphify release that produced it.
+
 **Works in** Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, and 15+ more — [pick your platform](#install).
 
 ---

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/analyze.py

@@ -630,24 +630,39 @@ def graph_diff(G_old: nx.Graph, G_new: nx.Graph) -> dict:
             return (u, v, data.get("relation", ""))
         return (min(u, v), max(u, v), data.get("relation", ""))
 
-    old_edge_keys = {
-        edge_key(G_old, u, v, d)
+    def edge_dir(data: dict) -> tuple | None:
+        # Stored direction of an undirected edge (build_from_json, load_node_link_graph).
+        if "_src" in data and "_tgt" in data:
+            return (data["_src"], data["_tgt"])
+        return None
+
+    old_edge_dirs = {
+        edge_key(G_old, u, v, d): edge_dir(d)
         for u, v, d in G_old.edges(data=True)
     }
-    new_edge_keys = {
-        edge_key(G_new, u, v, d)
+    new_edge_dirs = {
+        edge_key(G_new, u, v, d): edge_dir(d)
         for u, v, d in G_new.edges(data=True)
     }
-
-    added_edge_keys = new_edge_keys - old_edge_keys
-    removed_edge_keys = old_edge_keys - new_edge_keys
+    old_edge_keys = set(old_edge_dirs)
+    new_edge_keys = set(new_edge_dirs)
+
+    # A reversed edge (a->b became b->a) keeps its undirected key. Report it as
+    # removed + added only when both snapshots carry _src/_tgt and they differ,
+    # so graphs without the markers diff exactly as before (#4067).
+    reversed_edge_keys = {
+        k for k in old_edge_keys & new_edge_keys
+        if old_edge_dirs[k] and new_edge_dirs[k] and old_edge_dirs[k] != new_edge_dirs[k]
+    }
+    added_edge_keys = (new_edge_keys - old_edge_keys) | reversed_edge_keys
+    removed_edge_keys = (old_edge_keys - new_edge_keys) | reversed_edge_keys
 
     new_edges_list = []
     for u, v, d in G_new.edges(data=True):
         if edge_key(G_new, u, v, d) in added_edge_keys:
             new_edges_list.append({
-                "source": u,
-                "target": v,
+                "source": d.get("_src", u),
+                "target": d.get("_tgt", v),
                 "relation": d.get("relation", ""),
                 "confidence": d.get("confidence", ""),
             })
@@ -656,8 +671,8 @@ def graph_diff(G_old: nx.Graph, G_new: nx.Graph) -> dict:
     for u, v, d in G_old.edges(data=True):
         if edge_key(G_old, u, v, d) in removed_edge_keys:
             removed_edges_list.append({
-                "source": u,
-                "target": v,
+                "source": d.get("_src", u),
+                "target": d.get("_tgt", v),
                 "relation": d.get("relation", ""),
                 "confidence": d.get("confidence", ""),
             })

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/export.py

@@ -172,6 +172,20 @@ from graphify.exporters.base import COMMUNITY_COLORS  # noqa: E402,F401
 from graphify.exporters.html import to_html  # noqa: E402,F401
 
 
+# Increment when the persisted graph structure changes incompatibly for consumers.
+GRAPH_SCHEMA_VERSION = 1
+
+
+def _graphify_version() -> str | None:
+    """Return the installed graphify version for graph provenance."""
+    try:
+        from importlib.metadata import version
+
+        return version("graphifyy")
+    except Exception:
+        return None
+
+
 # Fallback scores for an edge that carries a confidence tier but no
 # confidence_score. The INFERRED default was 0.5, which references/extraction-spec.md
 # rules out in as many words — "never omit it, never use 0.5 as a default" — and
@@ -433,6 +447,11 @@ def to_json(G: nx.Graph, communities: dict[int, list[str]], output_path: str, *,
     if isinstance(data.get("graph"), dict) and "hyperedges" in data["graph"]:
         data["graph"]["hyperedges"] = hyperedges
     data["hyperedges"] = hyperedges
+    graph_metadata = data.setdefault("graph", {})
+    graph_metadata["schema_version"] = GRAPH_SCHEMA_VERSION
+    graphify_version = _graphify_version()
+    if graphify_version is not None:
+        graph_metadata["graphify_version"] = graphify_version
     # Fallback provenance comes from the repo the graph is being written INTO
     # (output_path lives in <target>/graphify-out/), never the shell's cwd —
     # the same cwd-anchoring mistake #2316 fixed for `update`.

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/extract.py

@@ -33,6 +33,8 @@ from graphify.extractors.base import (  # noqa: F401
     _LANGUAGE_BUILTIN_GLOBALS,
     _file_stem,
     _make_id,
+    _read_source_bytes,
+    _read_source_text,
     _read_text,
 )
 from graphify.extractors.apex import extract_apex  # noqa: F401
@@ -674,6 +676,23 @@ def _python_import_bindings(node, source: bytes) -> list[tuple[str, str]]:
     return bindings
 
 
+def _missing_relative_module_name(attempted: Path, root: Path, raw: str) -> str:
+    """Dotted module name, relative to ``root``, of an unresolved relative import.
+
+    ``attempted`` is the file the import would have named (``pkg/missing.py`` or
+    ``pkg/__init__.py``). Falls back to ``ref:`` + the raw specifier when the
+    import climbs above the scan root, so the id never carries an absolute path.
+    """
+    try:
+        rel = attempted.relative_to(root)
+    except ValueError:
+        return f"ref:{raw}"
+    parts = list(rel.with_suffix("").parts)
+    if parts and parts[-1] == "__init__":
+        parts.pop()
+    return ".".join(parts) if parts else f"ref:{raw}"
+
+
 def _import_python(
     node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str,
     scope_stack: list[str] | None = None, scan_root: Path | None = None,
@@ -749,13 +768,24 @@ def _import_python(
                 target_path = _resolve_python_module_path(
                     module_name, current_path, root, level=dots
                 )
+                missing = False
                 if target_path is None:
                     base = current_path.parent
                     for _ in range(dots - 1):
                         base = base.parent
                     rel = (module_name.replace(".", "/") + ".py") if module_name else "__init__.py"
                     target_path = base / rel
-                tgt_nid = _make_id(str(target_path))
+                    missing = not target_path.is_file()
+                if missing:
+                    # No file behind the import: minting the id from the
+                    # attempted absolute path bakes the checkout location (and
+                    # OS username) into the graph, and the root-relative id
+                    # remap never rewrites it. Use the dotted module name
+                    # relative to the scan root, the id an unresolved absolute
+                    # import of the same module already gets.
+                    tgt_nid = _make_id(_missing_relative_module_name(target_path, root, raw))
+                else:
+                    tgt_nid = _make_id(str(target_path))
             else:
                 # Use the shared scan-root-aware resolver for absolute imports.
                 # It stops at the corpus boundary and handles package roots the
@@ -1672,7 +1702,7 @@ def _extract_python_rationale(path: Path, result: dict) -> None:
         from tree_sitter import Language, Parser
         language = Language(tspython.language())
         parser = Parser(language)
-        source = path.read_bytes()
+        source = _read_source_bytes(path, warn=False)
         tree = parser.parse(source)
         root = tree.root_node
     except Exception:
@@ -2053,7 +2083,7 @@ def extract_js(path: Path) -> dict:
     source_override = None
     if is_ts:
         try:
-            source = path.read_bytes()
+            source = _read_source_bytes(path)
             source_override = _normalize_ts_import_types(source, tsx=suffix == ".tsx")
         except OSError:
             pass
@@ -2091,7 +2121,7 @@ def _rescue_js_dynamic_imports(path: Path, result: dict) -> None:
     """
     try:
         import re as _re
-        src = path.read_text(encoding="utf-8", errors="replace")
+        src = _read_source_text(path, warn=False)
         if not _re.search(r"(?<!\w)import\s*\(", src):  # cheap bail — most files have none
             return
         existing_ids = {n["id"] for n in result.get("nodes", [])}
@@ -2207,7 +2237,7 @@ def _extract_js_rationale(path: Path, result: dict) -> None:
     Mutates result in-place by appending to result['nodes'] and result['edges'].
     """
     try:
-        source_text = path.read_text(encoding="utf-8", errors="replace")
+        source_text = _read_source_text(path, warn=False)
     except Exception:
         return
 
@@ -2446,7 +2476,7 @@ def extract_svelte(path: Path) -> dict:
     dynamic imports.
     """
     try:
-        src = path.read_text(encoding="utf-8", errors="replace")
+        src = _read_source_text(path)
     except OSError as e:
         return {"nodes": [], "edges": [], "error": str(e)}
 
@@ -2555,7 +2585,7 @@ def extract_astro(path: Path) -> dict:
     file flagged every template as a syntax error and dropped frontmatter symbols.
     """
     try:
-        src = path.read_text(encoding="utf-8", errors="replace")
+        src = _read_source_text(path)
     except OSError:
         return {"nodes": [], "edges": []}
     masked = _astro_mask_non_script(src).encode("utf-8")
@@ -2563,7 +2593,7 @@ def extract_astro(path: Path) -> dict:
     result = _extract_generic(path, _TS_CONFIG, source_override=masked)
     try:
         import re as _re
-        src = path.read_text(encoding="utf-8", errors="replace")
+        src = _read_source_text(path, warn=False)
         existing_ids = {n["id"] for n in result.get("nodes", [])}
         file_node_id = _make_id(str(path))
         aliases = _load_tsconfig_aliases(path.parent)
@@ -2624,7 +2654,7 @@ def extract_vue(path: Path) -> dict:
     ``import('…')`` dynamic imports the AST does not edge.
     """
     try:
-        src = path.read_text(encoding="utf-8", errors="replace")
+        src = _read_source_text(path)
     except OSError:
         return {"nodes": [], "edges": []}
 
@@ -2674,7 +2704,7 @@ def _is_spock_file(path: Path, ts_result: dict) -> bool:
     import re as _re
     _SPOCK_FEATURE_RE = _re.compile(r"""^\s*def\s+[\"']""", _re.MULTILINE)
     try:
-        return bool(_SPOCK_FEATURE_RE.search(path.read_text(errors="replace")))
+        return bool(_SPOCK_FEATURE_RE.search(_read_source_text(path, warn=False)))
     except OSError:
         return False
 
@@ -2685,7 +2715,7 @@ def _extract_spock_fallback(path: Path, ts_result: dict) -> dict:
     (which survive reliably) with class and feature-method nodes extracted via regex.
     """
     import re as _re
-    source = path.read_text(errors="replace")
+    source = _read_source_text(path, warn=False)
     str_path = str(path)
     stem = _file_stem(path)
 
@@ -2825,7 +2855,7 @@ def _augment_cpp_string_tests(path: Path, result: dict) -> dict:
     commented Spock ``def "feature"()`` would).
     """
     try:
-        source = path.read_text(errors="replace")
+        source = _read_source_text(path, warn=False)
     except OSError:
         return result
     matches = list(_CPP_STRING_TEST_RE.finditer(source))
@@ -2962,6 +2992,60 @@ def _normalize_cpp_cli(source: bytes) -> bytes | None:
     return _CPP_CLI_ATTR_RE.sub(_blank_keeping_newlines, out)
 
 
+_CPP_EXPORT_MACRO_RE = re.compile(
+    # Match `class` or `struct`
+    rb"(\b(?:class|struct)[ \t\r\n]+)"
+    # Match one or more ALL-CAPS macros (stacked or single)
+    rb"((?:[A-Z][A-Z0-9_]*[ \t\r\n]+)+)"
+    # Negative lookahead: the matched class name cannot be exactly "final"
+    rb"(?!final[ \t\r\n]*[:{])"
+    # Match the actual class name (and optional final), ending with `:` or `{`
+    rb"([A-Za-z_][A-Za-z0-9_]*(?:[ \t\r\n]+final)?[ \t\r\n]*)([:{])"
+)
+
+
+def _normalize_cpp_export_macros(source: bytes) -> bytes:
+    """Blank an export macro between ``class``/``struct`` and the type name.
+
+    Single ALL-CAPS identifier macros (and stacked ones) are handled.
+    Note: paren-attribute macros like ``__declspec(dllexport)`` and
+    ``__attribute__((visibility("default")))`` are currently unsupported,
+    as well as template specializations (e.g. ``template<> class MODULE_API Widget<int>``).
+    """
+
+    def repl(m: re.Match[bytes]) -> bytes:
+        start = m.start()
+
+        # Check if preceded by `(` (e.g. range-based for loop `for(class MACRO var: items)`)
+        idx = start - 1
+        while idx >= 0 and source[idx] in b" \t\r\n":
+            idx -= 1
+        if idx >= 0 and source[idx] == ord(b"("):
+            return m.group(0)
+
+        # Check for brace initialization like `var{1}`
+        if m.group(4) == b"{":
+            end = m.end()
+            idx_after = end
+            while idx_after < len(source) and source[idx_after] in b" \t\r\n":
+                idx_after += 1
+            if idx_after < len(source):
+                next_char = source[idx_after : idx_after + 1]
+                if next_char in b"0123456789\"'-":
+                    return m.group(0)
+
+        # Blank the macro with spaces to preserve offsets, but KEEP NEWLINES!
+        macro_text = m.group(2)
+        blanked_macro = bytearray(macro_text)
+        for i in range(len(blanked_macro)):
+            if blanked_macro[i] not in b"\r\n":
+                blanked_macro[i] = ord(b" ")
+
+        return m.group(1) + bytes(blanked_macro) + m.group(3) + m.group(4)
+
+    return _CPP_EXPORT_MACRO_RE.sub(repl, source)
+
+
 def extract_cpp(path: Path) -> dict:
     """Extract functions, classes, and includes from a .cpp/.cc/.cxx/.hpp file.
 
@@ -2972,12 +3056,14 @@ def extract_cpp(path: Path) -> dict:
     drops as ERROR nodes (issue #2594), mirroring the Spock fallback for Groovy.
     """
     try:
-        source = path.read_bytes()
+        source = _read_source_bytes(path)
     except OSError:
         # Let _extract_generic report the read failure in its usual shape.
         return _augment_cpp_string_tests(path, _extract_generic(path, _CPP_CONFIG))
+    source_override = _normalize_cpp_cli(source) or source
+    source_override = _normalize_cpp_export_macros(source_override)
     result = _extract_generic(
-        path, _CPP_CONFIG, source_override=_normalize_cpp_cli(source) or source
+        path, _CPP_CONFIG, source_override=source_override
     )
     return _augment_cpp_string_tests(path, result)
 
@@ -3055,7 +3141,7 @@ def extract_php(path: Path) -> dict:
     """
     result = _extract_generic(path, _PHP_CONFIG)
     try:
-        src = path.read_text(encoding="utf-8", errors="replace")
+        src = _read_source_text(path, warn=False)
         masked, had_script = _php_mask_to_script_blocks(src)
         if not had_script:
             return result
@@ -4679,13 +4765,14 @@ def _resolve_csharp_member_calls(
             type_nid = bases[0]
             type_qualified = True
         elif receiver[:1].isupper():
-            # Type.M() — the type is named explicitly (also covers a Pascal-cased
-            # local whose name equals its type, resolved via the table below if the
-            # explicit-type lookup misses).
-            type_nid = _resolve_type_name_nid(receiver, caller_node, src_file)
+            # Type.M() — the type is named explicitly. A field/property/local of
+            # that name in scope shadows the type (`IStore Store => ...;
+            # Store.Save()`, #3797), so the receiver's declared type from the
+            # table wins when known; otherwise fall back to the type name.
+            type_name = rc.get("receiver_type")
+            type_nid = _resolve_type_name_nid(type_name, caller_node, src_file)
             if not type_nid:
-                type_name = rc.get("receiver_type")
-                type_nid = _resolve_type_name_nid(type_name, caller_node, src_file)
+                type_nid = _resolve_type_name_nid(receiver, caller_node, src_file)
                 if not type_nid:
                     _park_if_absent(type_name or receiver, caller_node, rc)
                     continue
@@ -6337,7 +6424,7 @@ def _xaml_codebehind_symbols(
     # parameter list on method nodes, so we read it from the code-behind source
     # at the method's recorded line.
     try:
-        cb_lines = codebehind.read_text(encoding="utf-8", errors="replace").splitlines()
+        cb_lines = _read_source_text(codebehind, warn=False).splitlines()
     except OSError:
         cb_lines = []
 
@@ -6523,7 +6610,7 @@ def _xaml_communitytoolkit_members(vm_node: dict) -> tuple[dict[str, dict], list
     try:
         # errors="replace" so a non-UTF8 code-behind can't raise UnicodeDecodeError
         # and abort the whole extract_xaml (matches every other reader here).
-        lines = Path(source_file).read_text(encoding="utf-8", errors="replace").splitlines()
+        lines = _read_source_text(Path(source_file), warn=False).splitlines()
     except OSError:
         return {}, []
 

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/extractors/apex.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 
 from pathlib import Path
-from graphify.extractors.base import _file_stem, _make_id
+from graphify.extractors.base import _file_stem, _make_id, _read_source_text
 
 
 def extract_apex(path: Path) -> dict:
@@ -11,7 +11,7 @@ def extract_apex(path: Path) -> dict:
     Apex .cls and .trigger files using regex (no tree-sitter grammar on PyPI)."""
     import re as _re
     try:
-        source = path.read_text(encoding="utf-8", errors="replace")
+        source = _read_source_text(path)
     except OSError:
         return {"nodes": [], "edges": []}
 

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/extractors/base.py

@@ -1,6 +1,7 @@
 # DO NOT import from graphify.extract here — direction is extract.py → extractors/ only.
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 
 from graphify.ids import make_id
@@ -83,3 +84,70 @@ def _file_stem(path: Path) -> str:
 
 def _read_text(node, source: bytes) -> str:
     return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+
+
+_UTF32_BOMS = (b"\xff\xfe\x00\x00", b"\x00\x00\xfe\xff")
+_UTF16_BOMS = (b"\xff\xfe", b"\xfe\xff")
+# Fixed, not the host locale: extraction must give the same graph on every
+# machine (CONTRIBUTING: deterministic extraction).
+_SOURCE_FALLBACK_ENCODINGS = ("cp1252", "latin-1")
+_warned_source_encodings: set[str] = set()
+
+
+def _read_source_bytes(path: Path, *, warn: bool = True) -> bytes:
+    """Read a source file as the UTF-8 bytes tree-sitter parses.
+
+    tree-sitter treats its input as UTF-8. Raw bytes in another encoding were
+    parsed as-is: a UTF-16 file (interleaved NUL bytes) produced no nodes at
+    all, and a Windows-1252 identifier was cut at its first non-UTF-8 byte
+    (``CaféOrder`` came out as ``Order``) — both silently.
+
+    Valid UTF-8, with or without a BOM, is returned byte-for-byte, so node ids,
+    byte offsets and cache keys for those files are unchanged. A UTF-16 or
+    UTF-32 file with a BOM is decoded exactly and re-encoded as UTF-8. Anything
+    else is decoded as cp1252, then latin-1 (which cannot fail), so names come
+    out whole; line numbers are unchanged in every case. ``warn`` names the file
+    once per process on that last, guessed path — pass ``warn=False`` from
+    secondary passes that re-read a file the extractor already read.
+    """
+    raw = path.read_bytes()
+    if raw.isascii():
+        return raw
+    try:
+        raw.decode("utf-8")
+        return raw
+    except UnicodeDecodeError:
+        pass
+    for boms, encoding in ((_UTF32_BOMS, "utf-32"), (_UTF16_BOMS, "utf-16")):
+        if raw.startswith(boms):
+            try:
+                return raw.decode(encoding).encode("utf-8")
+            except UnicodeDecodeError:
+                continue  # FF FE 00 00 is also UTF-16-LE: BOM + U+0000
+    for encoding in _SOURCE_FALLBACK_ENCODINGS:
+        try:
+            text = raw.decode(encoding)
+        except UnicodeDecodeError:
+            continue
+        key = str(path)
+        if warn and key not in _warned_source_encodings:
+            _warned_source_encodings.add(key)
+            print(
+                f"[graphify] WARNING: {path} is not valid UTF-8; read it as {encoding}. "
+                "Re-save it as UTF-8 if names in the graph look wrong.",
+                file=sys.stderr,
+            )
+        return text.encode("utf-8")
+    return raw  # unreachable: latin-1 decodes every byte
+
+
+def _read_source_text(path: Path, *, warn: bool = True) -> str:
+    """``_read_source_bytes`` as text, for extractors that work on ``str``.
+
+    Matches ``path.read_text(encoding="utf-8")`` exactly for every valid UTF-8
+    file, including its universal-newline translation (``\\r\\n`` and a lone
+    ``\\r`` both become ``\\n``) and a kept BOM, so regex extractors see the same
+    text they always did.
+    """
+    text = _read_source_bytes(path, warn=warn).decode("utf-8")
+    return text.replace("\r\n", "\n").replace("\r", "\n")

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/extractors/bash.py

@@ -6,7 +6,7 @@ import re
 from pathlib import Path
 from typing import Any
 
-from graphify.extractors.base import _file_stem, _make_id, _read_text
+from graphify.extractors.base import _file_stem, _make_id, _read_source_bytes, _read_text
 
 
 # Leading `${VAR}` / `$VAR` expansion segment(s) of a `source` path argument. The
@@ -113,7 +113,7 @@ def extract_bash(path: Path) -> dict:
     try:
         language = Language(tsbash.language())
         parser = Parser(language)
-        source = path.read_bytes()
+        source = _read_source_bytes(path)
         tree = parser.parse(source)
         root = tree.root_node
     except Exception as e:

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/extractors/blade.py

@@ -3,14 +3,14 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from graphify.extractors.base import _make_id
+from graphify.extractors.base import _make_id, _read_source_text
 
 
 def extract_blade(path: Path) -> dict:
     """Extract @extends, @include, <livewire:> components, and wire:click bindings from Blade templates."""
     import re
     try:
-        src = path.read_text(encoding="utf-8", errors="replace")
+        src = _read_source_text(path)
     except OSError:
         return {"error": f"cannot read {path}"}
 

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/extractors/cobol.py

@@ -5,7 +5,7 @@ import re
 from pathlib import Path
 from typing import Any
 
-from graphify.extractors.base import _make_id
+from graphify.extractors.base import _make_id, _read_source_text
 
 
 _NAME = r"[A-Z0-9][A-Z0-9-]*"
@@ -98,7 +98,7 @@ def _starts_inside_string(code: str, offset: int) -> bool:
 
 def extract_cobol(path: Path) -> dict:
     try:
-        source = path.read_text(encoding="utf-8", errors="replace")
+        source = _read_source_text(path)
     except OSError as exc:
         return {"nodes": [], "edges": [], "error": str(exc)}
 

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/extractors/commonlisp.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import warnings
 from pathlib import Path
 
-from graphify.extractors.base import _file_stem, _make_id
+from graphify.extractors.base import _file_stem, _make_id, _read_source_bytes
 
 
 # Standard CL definer forms that introduce data/type/variable bindings
@@ -78,7 +78,7 @@ def extract_commonlisp(path: Path) -> dict:
             )
             language = Language(tscl.language())
         parser = Parser(language)
-        source = path.read_bytes()
+        source = _read_source_bytes(path)
         tree = parser.parse(source)
         root = tree.root_node
     except Exception as e:

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/extractors/dart.py

@@ -4,13 +4,13 @@ from __future__ import annotations
 import re
 
 from pathlib import Path
-from graphify.extractors.base import _file_stem, _make_id
+from graphify.extractors.base import _file_stem, _make_id, _read_source_text
 
 
 def extract_dart(path: Path) -> dict:
     """Extract classes, mixins, functions, imports, generic calls, and annotations from a .dart file using regex."""
     try:
-        src = path.read_text(encoding="utf-8", errors="replace")
+        src = _read_source_text(path)
     except OSError:
         return {"error": f"cannot read {path}"}
 

{graphifyy-0.9.77 → graphifyy-0.9.78}/graphify/extractors/dm.py

@@ -5,7 +5,13 @@ import re
 
 from pathlib import Path
 from typing import Any
-from graphify.extractors.base import _file_stem, _make_id, _read_text
+from graphify.extractors.base import (
+    _file_stem,
+    _make_id,
+    _read_source_bytes,
+    _read_source_text,
+    _read_text,
+)
 
 
 def extract_dm(path: Path) -> dict:
@@ -18,7 +24,7 @@ def extract_dm(path: Path) -> dict:
     try:
         language = Language(tsdm.language())
         parser = Parser(language)
-        source = path.read_bytes()
+        source = _read_source_bytes(path)
         tree = parser.parse(source)
         root = tree.root_node
     except Exception as e:
@@ -366,7 +372,7 @@ def extract_dmm(path: Path) -> dict:
     try:
         if path.stat().st_size > 50 * 1024 * 1024:
             return {"nodes": [], "edges": [], "error": "file too large (>50 MB)"}
-        text = path.read_text(encoding="utf-8", errors="replace")
+        text = _read_source_text(path)
     except Exception as e:
         return {"nodes": [], "edges": [], "error": str(e)}
 
@@ -436,7 +442,7 @@ _DMF_TYPE_RE = re.compile(r'^\s*type\s*=\s*(\S+)\s*$')
 def extract_dmf(path: Path) -> dict:
     """Extract windows and controls from a .dmf interface file."""
     try:
-        text = path.read_text(encoding="utf-8", errors="replace")
+        text = _read_source_text(path)
     except Exception as e:
         return {"nodes": [], "edges": [], "error": str(e)}
 
@@ -449,6 +455,7 @@ def extract_dmf(path: Path) -> dict:
     seen: set[str] = {file_nid}
 
     current_window_nid: str | None = None
+    current_window_name: str | None = None
     current_elem_nid: str | None = None
     current_elem_name: str | None = None
 
@@ -465,13 +472,19 @@ def extract_dmf(path: Path) -> dict:
                               "confidence": "EXTRACTED", "source_file": str_path,
                               "source_location": f"L{line_idx}", "weight": 1.0})
             current_window_nid = nid
+            current_window_name = name
             current_elem_nid = None
             current_elem_name = None
             continue
         m = _DMF_ELEM_RE.match(line)
-        if m and current_window_nid is not None:
+        if m and current_window_nid is not None and current_window_name is not None:
             name = m.group(1)
-            nid = _make_id(stem, "elem", current_window_nid, name)
+            # Key on the window NAME, not its node id: the id already embeds
+            # `stem`, which is absolute at extraction time. extract()'s
+            # id-remap only rewrites the leading stem, so the copy nested in
+            # the middle kept the checkout path (and OS username) in every
+            # element id.
+            nid = _make_id(stem, "elem", current_window_name, name)
             if nid not in seen:
                 seen.add(nid)
                 nodes.append({"id": nid, "label": f'elem "{name}"', "file_type": "code",