graphify-sf 0.3.4__tar.gz → 0.3.6__tar.gz

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify-sf
-Version: 0.3.4
+Version: 0.3.6
 Summary: Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required.
 Author: Ray Kuo
 License-Expression: MIT
@@ -25,6 +25,7 @@ License-File: LICENSE
 Requires-Dist: networkx>=3.0
 Requires-Dist: datasketch>=1.6
 Requires-Dist: rapidfuzz>=3.0
+Requires-Dist: pathspec>=0.12
 Requires-Dist: idna>=3.15
 Provides-Extra: leiden
 Requires-Dist: graspologic; python_version < "3.13" and extra == "leiden"
@@ -700,9 +701,33 @@ All configuration via environment variables:
 | `GRAPHIFY_SF_REBUILD_MEMORY_LIMIT_MB` | `` | Cap memory usage for background watch rebuilds (MB) |
 | `CLAUDE_CONFIG_DIR` | `~/.claude` | Override Claude Code config directory — only set if your Claude Code config lives at a non-standard path (company-managed dotfiles, CI, or multiple installations) |
 
-### `.graphifysfignore`
+### Ignoring files (`.gitignore`, `.forceignore`, `.graphifysfignore`)
 
-Place a `.graphifysfignore` file at your project root to exclude files/directories from scanning (same syntax as `.gitignore` glob patterns):
+By default graphify-sf **respects your project's `.gitignore` and `.forceignore`** so that
+deprecated metadata, `__tests__`, queues, editor/lint scaffolding, and build output don't become
+noise in the graph. Patterns use full gitignore semantics (negation `!keep`, anchored `/foo`,
+directory `foo/`, `**`), parsed with `pathspec` — the same way git and the `sf` CLI read them. The
+ignore files are found by walking **up** from the path you scan, so `graphify-sf force-app` still
+honors the `.gitignore`/`.forceignore` at your project root.
+
+After a scan, any skipped files are reported honestly:
+
+```
+[graphify-sf] 5573 metadata files found, 57 skipped
+[graphify-sf] skipped 57 files (.forceignore: 57) — use --include-ignored to include them
+```
+
+To scan **everything** regardless of `.gitignore`/`.forceignore` (e.g. you suspect a real metadata
+file was excluded):
+
+```bash
+graphify-sf <path> --include-ignored
+```
+
+#### `.graphifysfignore`
+
+For graphify-specific exclusions independent of git/SF, place a `.graphifysfignore` file at your
+project root (glob patterns, always applied):
 
 ```
 # Exclude test data

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/README.md

@@ -625,9 +625,33 @@ All configuration via environment variables:
 | `GRAPHIFY_SF_REBUILD_MEMORY_LIMIT_MB` | `` | Cap memory usage for background watch rebuilds (MB) |
 | `CLAUDE_CONFIG_DIR` | `~/.claude` | Override Claude Code config directory — only set if your Claude Code config lives at a non-standard path (company-managed dotfiles, CI, or multiple installations) |
 
-### `.graphifysfignore`
+### Ignoring files (`.gitignore`, `.forceignore`, `.graphifysfignore`)
 
-Place a `.graphifysfignore` file at your project root to exclude files/directories from scanning (same syntax as `.gitignore` glob patterns):
+By default graphify-sf **respects your project's `.gitignore` and `.forceignore`** so that
+deprecated metadata, `__tests__`, queues, editor/lint scaffolding, and build output don't become
+noise in the graph. Patterns use full gitignore semantics (negation `!keep`, anchored `/foo`,
+directory `foo/`, `**`), parsed with `pathspec` — the same way git and the `sf` CLI read them. The
+ignore files are found by walking **up** from the path you scan, so `graphify-sf force-app` still
+honors the `.gitignore`/`.forceignore` at your project root.
+
+After a scan, any skipped files are reported honestly:
+
+```
+[graphify-sf] 5573 metadata files found, 57 skipped
+[graphify-sf] skipped 57 files (.forceignore: 57) — use --include-ignored to include them
+```
+
+To scan **everything** regardless of `.gitignore`/`.forceignore` (e.g. you suspect a real metadata
+file was excluded):
+
+```bash
+graphify-sf <path> --include-ignored
+```
+
+#### `.graphifysfignore`
+
+For graphify-specific exclusions independent of git/SF, place a `.graphifysfignore` file at your
+project root (glob patterns, always applied):
 
 ```
 # Exclude test data

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/graphify_sf/__main__.py

@@ -183,6 +183,7 @@ def _run_pipeline(
     force: bool = False,
     backend: str | None = None,
     token_budget: int = 40_000,
+    respect_ignore: bool = True,
 ) -> None:
     """Full pipeline: detect → extract → [LLM] → build → cluster → report → export."""
     from graphify_sf.analyze import god_nodes, suggest_questions, surprising_connections
@@ -201,18 +202,27 @@ def _run_pipeline(
 
     if incremental:
         print(f"[graphify-sf] incremental scan of {target}")
-        detection = detect_incremental(target, manifest_path=str(manifest_path))
+        detection = detect_incremental(target, manifest_path=str(manifest_path), respect_ignore=respect_ignore)
     else:
         print(f"[graphify-sf] scanning {target}")
-        detection = detect(target)
+        detection = detect(target, respect_ignore=respect_ignore)
 
     total = detection.get("total_files", 0)
-    skipped = detection.get("skipped", 0)
+    skipped_count = detection.get("skipped_count", 0)
+    skipped_by_source = detection.get("skipped_by_source", {})
     warning = detection.get("warning", "")
     if warning:
         print(f"[graphify-sf] WARNING: {warning}", file=sys.stderr)
 
-    print(f"[graphify-sf] {total} metadata files found, {skipped} skipped")
+    print(f"[graphify-sf] {total} metadata files found, {skipped_count} skipped")
+    # Honesty-layer: never silently drop files — show which ignore source skipped what.
+    if skipped_count:
+        nonzero = {k: v for k, v in skipped_by_source.items() if v}
+        if nonzero:
+            detail = ", ".join(f"{k}: {v}" for k, v in nonzero.items())
+            print(f"[graphify-sf] skipped {skipped_count} files ({detail}) — use --include-ignored to include them")
+    elif not respect_ignore:
+        print("[graphify-sf] --include-ignored: .gitignore/.forceignore not applied")
 
     if total == 0:
         print("[graphify-sf] no Salesforce metadata files found — nothing to extract", file=sys.stderr)
@@ -1564,6 +1574,8 @@ def main() -> None:
         print("    --directed                       build directed graph")
         print("    --no-viz                         skip graph.html generation")
         print("    --force                          overwrite graph.json even if new graph is smaller")
+        print("    --include-ignored                scan files matched by .gitignore/.forceignore")
+        print("                                     (default: those files are skipped)")
         print("    --max-workers N                  parallel extraction worker count")
         print("    --backend <name>                 add AI semantic extraction layer")
         print("      backends: claude, gemini, kimi, openai, bedrock, ollama, auto")
@@ -1929,6 +1941,7 @@ def main() -> None:
         max_workers = None
         backend: str | None = None
         token_budget = 40_000
+        respect_ignore = True
 
         i = 1
         while i < len(args):
@@ -1951,6 +1964,9 @@ def main() -> None:
             elif a == "--force":
                 force = True
                 i += 1
+            elif a in ("--include-ignored", "--no-respect-ignore"):
+                respect_ignore = False
+                i += 1
             elif a == "--max-workers" and i + 1 < len(args):
                 max_workers = int(args[i + 1])
                 i += 2
@@ -1983,6 +1999,7 @@ def main() -> None:
             force=force,
             backend=backend,
             token_budget=token_budget,
+            respect_ignore=respect_ignore,
         )
         return
 

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/graphify_sf/build.py

@@ -23,6 +23,27 @@ def _norm_source_file(p: str | None) -> str | None:
     return p.replace("\\", "/") if p else p
 
 
+# Relation priority for the rare case where a simple (non-multi) graph must pick
+# ONE relation for a node-pair that has two (e.g. self-referencing lookups, where
+# object→field `contains` collides with field→object `references`). Higher wins.
+# Structural ownership (`contains`) outranks looser relations so that
+# componentsOnObject / bfsImpact keep working. Unknown relations get a low default.
+_RELATION_PRIORITY: dict[str, int] = {
+    "contains": 100,
+    "master_detail": 90,
+    "calls": 70,
+    "triggers": 70,
+    "dml": 60,
+    "queries": 55,
+    "references": 50,
+    "grants": 40,
+}
+
+
+def _relation_priority(relation: str | None) -> int:
+    return _RELATION_PRIORITY.get(relation or "", 10)
+
+
 def edge_data(G: nx.Graph, u: str, v: str) -> dict:
     raw = G[u][v]
     if isinstance(G, (nx.MultiGraph, nx.MultiDiGraph)):
@@ -87,6 +108,17 @@ def build_from_json(extraction: dict, *, directed: bool = False) -> nx.Graph:
             attrs["source_file"] = _norm_source_file(attrs["source_file"])
         attrs["_src"] = src
         attrs["_tgt"] = tgt
+        # In a simple (non-multi) graph a node-pair holds ONE edge, so adding a
+        # second edge between the same pair overwrites the first. This happens for
+        # self-referencing lookups (object→field `contains` + field→object
+        # `references` are the same undirected pair). Keep the structurally more
+        # important relation: `contains` (ownership, used by componentsOnObject /
+        # bfsImpact) must win over a weaker relation rather than be overwritten.
+        # (Full multi-relation preservation is the 0.4.0 MultiGraph work.)
+        if not isinstance(G, (nx.MultiGraph, nx.MultiDiGraph)) and G.has_edge(src, tgt):
+            existing_rel = G.get_edge_data(src, tgt).get("relation")
+            if _relation_priority(existing_rel) >= _relation_priority(attrs.get("relation")):
+                continue  # keep the existing higher/equal-priority edge
         G.add_edge(src, tgt, **attrs)
 
     hyperedges = extraction.get("hyperedges", [])
@@ -337,15 +369,31 @@ def _norm_label(label: str) -> str:
 
 
 def deduplicate_by_label(nodes: list[dict], edges: list[dict]) -> tuple[list[dict], list[dict]]:
-    """Merge nodes that share a normalised label, rewriting edge references."""
+    """Merge nodes that share a normalised label AND sf_type, rewriting edge references.
+
+    The merge is gated on ``sf_type`` so that distinct components which happen to
+    normalise to the same label are NOT conflated — e.g. an ApexClass and an
+    LWCComponent named ``CauRefreshIntervention``, or a CustomObject and its
+    CustomTab/Settings. Merging across types previously rewrote their edges onto the
+    wrong survivor and dropped real ``contains``/``references`` edges (notably the
+    object→field ownership edge when an object's label collided with a permset/tab).
+    Same-type merges (the intended case: chunked duplicates carrying a ``_cN`` suffix)
+    are preserved.
+    """
     _CHUNK_SUFFIX = re.compile(r"_c\d+$")
-    canonical: dict[str, dict] = {}
+    canonical: dict[tuple[str, str], dict] = {}
     remap: dict[str, str] = {}
 
     for node in nodes:
-        key = _norm_label(node.get("label", node.get("id", "")))
-        if not key:
+        label_key = _norm_label(node.get("label", node.get("id", "")))
+        if not label_key:
             continue
+        # Only nodes of the same sf_type may merge, so distinct components that
+        # happen to share a normalised label are not conflated. When sf_type is
+        # absent (synthetic/untyped nodes), fall back to label-only merging so the
+        # historical behaviour is preserved for those.
+        type_key = node.get("sf_type") or ""
+        key = (type_key, label_key)
         existing = canonical.get(key)
         if existing is None:
             canonical[key] = node

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/graphify_sf/detect.py

@@ -2,9 +2,15 @@ import fnmatch
 import hashlib
 import json
 import os
+import sys
 from enum import Enum
 from pathlib import Path
 
+try:
+    import pathspec  # gitwildmatch — correct .gitignore/.forceignore semantics
+except ImportError:  # pragma: no cover - pathspec is a core dependency
+    pathspec = None
+
 
 class SFFileType(str, Enum):
     APEX = "apex"
@@ -180,7 +186,7 @@ def _load_sfgraphignore(root: Path) -> list[str]:
 
 
 def _is_ignored(path: Path, root: Path, patterns: list[str]) -> bool:
-    """Return True if the path matches any ignore pattern."""
+    """Return True if the path matches any .graphifysfignore pattern (fnmatch)."""
     if not patterns:
         return False
     try:
@@ -195,6 +201,59 @@ def _is_ignored(path: Path, root: Path, patterns: list[str]) -> bool:
     return False
 
 
+# ---------------------------------------------------------------------------
+# .gitignore / .forceignore support (gitwildmatch semantics via pathspec)
+# ---------------------------------------------------------------------------
+# Files honored by default. A user can opt out entirely with respect_ignore=False
+# (CLI: --include-ignored) to scan everything regardless of these declarations.
+_IGNORE_FILES = (".gitignore", ".forceignore")
+
+
+def _load_ignore_specs(root: Path) -> dict[str, tuple[Path, object]]:
+    """Load .gitignore / .forceignore as pathspec matchers, searching upward.
+
+    SFDX ignore files conventionally live at the project root, but users often
+    point graphify at a subdir (e.g. ``force-app``). Like git/sf, we walk up from
+    ``root`` to the filesystem root to find the nearest ``.gitignore`` and
+    ``.forceignore``. Each spec is returned with the directory it was found in, so
+    path matching is anchored relative to that base (correct gitwildmatch semantics).
+
+    Returns {filename: (base_dir, PathSpec)}.
+    """
+    specs: dict[str, tuple[Path, object]] = {}
+    if pathspec is None:
+        return specs
+    for name in _IGNORE_FILES:
+        d = root
+        while True:
+            f = d / name
+            if f.exists():
+                try:
+                    lines = f.read_text(encoding="utf-8", errors="ignore").splitlines()
+                    specs[name] = (d, pathspec.PathSpec.from_lines("gitignore", lines))
+                except OSError:
+                    pass
+                break
+            if d.parent == d:
+                break
+            d = d.parent
+    return specs
+
+
+def _matched_ignore_file(path: Path, root: Path, specs: dict[str, tuple[Path, object]]) -> str | None:
+    """Return the name of the first ignore file whose patterns match `path`, else None."""
+    if not specs:
+        return None
+    for name, (base, spec) in specs.items():
+        try:
+            rel = path.relative_to(base).as_posix()
+        except ValueError:
+            continue
+        if spec.match_file(rel):  # type: ignore[attr-defined]
+            return name
+    return None
+
+
 def extract_pdf_text(path: Path) -> str:
     """Extract plain text from a PDF using pypdf. Returns '' if pypdf not installed."""
     try:
@@ -312,16 +371,32 @@ def _classify_doc_file(path: Path) -> DocFileType | None:
     return None
 
 
-def detect(root: Path) -> dict:
-    """Scan the SFDX project and return detected files grouped by type."""
+def detect(root: Path, *, respect_ignore: bool = True) -> dict:
+    """Scan the SFDX project and return detected files grouped by type.
+
+    When ``respect_ignore`` is True (default), files matching the project's
+    ``.gitignore`` or ``.forceignore`` are skipped (gitwildmatch semantics).
+    Pass ``respect_ignore=False`` (CLI: ``--include-ignored``) to scan everything
+    regardless of those declarations. The hardcoded ``_SKIP_DIRS`` floor and the
+    ``.graphifysfignore`` file are always applied.
+    """
     root = root.resolve()
     files = {ft.value: [] for ft in SFFileType}
     doc_files: dict[str, list[str]] = {ft.value: [] for ft in DocFileType}
     bundle_dirs = {"lwc": [], "aura": []}
     skipped = []
+    # Per-source skip counts for an honest summary line (never silently drop).
+    skipped_by_source: dict[str, int] = {".gitignore": 0, ".forceignore": 0, ".graphifysfignore": 0}
     ignore_patterns = _load_sfgraphignore(root)
+    ignore_specs = _load_ignore_specs(root) if respect_ignore else {}
     converted_dir = root / "graphify-sf-out" / "converted"
 
+    def _skip_reason(path: Path) -> str | None:
+        """Return the ignore-source name if path should be skipped, else None."""
+        if _is_ignored(path, root, ignore_patterns):
+            return ".graphifysfignore"
+        return _matched_ignore_file(path, root, ignore_specs)
+
     for dirpath, dirnames, filenames in os.walk(root):
         dp = Path(dirpath)
 
@@ -330,20 +405,30 @@ def detect(root: Path) -> dict:
 
         # Check for LWC/Aura bundles
         if dp.parent.name == "lwc" and _is_lwc_bundle(dp):
-            if not _is_ignored(dp, root, ignore_patterns):
+            reason = _skip_reason(dp)
+            if reason is None:
                 bundle_dirs["lwc"].append(str(dp))
+            else:
+                skipped.append(str(dp))
+                skipped_by_source[reason] = skipped_by_source.get(reason, 0) + 1
             continue
 
         if dp.parent.name == "aura" and _is_aura_bundle(dp):
-            if not _is_ignored(dp, root, ignore_patterns):
+            reason = _skip_reason(dp)
+            if reason is None:
                 bundle_dirs["aura"].append(str(dp))
+            else:
+                skipped.append(str(dp))
+                skipped_by_source[reason] = skipped_by_source.get(reason, 0) + 1
             continue
 
         # Classify individual files
         for fname in filenames:
             path = dp / fname
-            if _is_ignored(path, root, ignore_patterns):
+            reason = _skip_reason(path)
+            if reason is not None:
                 skipped.append(str(path))
+                skipped_by_source[reason] = skipped_by_source.get(reason, 0) + 1
                 continue
             # Try SF classification first
             ftype = _classify_file(path)
@@ -361,16 +446,12 @@ def detect(root: Path) -> dict:
                         if md_path:
                             doc_files[dtype.value].append(str(md_path))
                         else:
-                            import sys
-
                             print(
                                 f"[graphify-sf] WARNING: {path.name} skipped — "
                                 "install graphify-sf[docs] to enable office file support",
                                 file=sys.stderr,
                             )
                     except Exception as exc:
-                        import sys
-
                         print(f"[graphify-sf] WARNING: office conversion failed for {path}: {exc}", file=sys.stderr)
                 else:
                     doc_files[dtype.value].append(str(path))
@@ -389,6 +470,9 @@ def detect(root: Path) -> dict:
         "bundle_dirs": bundle_dirs,
         "warning": None,
         "skipped": skipped,
+        "skipped_count": len(skipped),
+        "skipped_by_source": skipped_by_source,
+        "respect_ignore": respect_ignore,
     }
 
 
@@ -431,9 +515,9 @@ def save_manifest(
     Path(manifest_path).write_text(json.dumps(manifest, indent=2), encoding="utf-8")
 
 
-def detect_incremental(root: Path, manifest_path: str) -> dict:
+def detect_incremental(root: Path, manifest_path: str, *, respect_ignore: bool = True) -> dict:
     """Like detect(), but returns only new or modified files since the last run."""
-    full = detect(root)
+    full = detect(root, respect_ignore=respect_ignore)
     manifest = load_manifest(manifest_path)
 
     if not manifest:

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/graphify_sf/extract/apex.py

@@ -46,6 +46,18 @@ _TRIGGER_RE = re.compile(
 # Apex → Flow: Flow.Interview.FlowApiName
 _FLOW_INVOKE_RE = re.compile(r"Flow\.Interview\.(\w+)", re.IGNORECASE)
 
+# Variable declaration patterns used to resolve DML operands to their declared SObject type.
+# Simple: TypeName varName [= ...] ; or TypeName varName , or TypeName varName )
+_VAR_DECL_SIMPLE_RE = re.compile(
+    r"\b([A-Z]\w*)\s+([a-z]\w*)\s*(?=[=;,)])",
+    re.MULTILINE,
+)
+# Generic: List<T>/Set<T>/Map<K,V> varName [= ...] ; or , or )
+_VAR_DECL_GENERIC_RE = re.compile(
+    r"\b(?:List|Set|Map)\s*<([^>]+)>\s+([a-z]\w*)\s*(?=[=;,)])",
+    re.IGNORECASE | re.MULTILINE,
+)
+
 # Apex keywords that look like calls but aren't class references
 _APEX_KEYWORDS = frozenset(
     {
@@ -134,6 +146,34 @@ _APEX_KEYWORDS = frozenset(
     }
 )
 
+
+def _extract_var_types(text: str) -> dict[str, str]:
+    """Return a varName → declared SObject type map from class source text.
+
+    Handles simple declarations (TypeName var), generic collections
+    (List<T>/Set<T>/Map<K,V> var), and method parameters.
+    Variable names must start with a lowercase letter; types must be PascalCase
+    and not be an Apex keyword/primitive.
+    """
+    result: dict[str, str] = {}
+    # Generic declarations first (higher priority, e.g. List<Account> accs)
+    for m in _VAR_DECL_GENERIC_RE.finditer(text):
+        inner = m.group(1)
+        var_name = m.group(2)
+        parts = [p.strip() for p in inner.split(",")]
+        # For Map<K, V> take the last type arg; strip any nested generics
+        inner_type = re.sub(r"<[^>]*>", "", parts[-1]).strip()
+        if inner_type and inner_type[0].isupper() and inner_type.lower() not in _APEX_KEYWORDS:
+            result.setdefault(var_name, inner_type)
+    # Simple declarations: TypeName varName
+    for m in _VAR_DECL_SIMPLE_RE.finditer(text):
+        type_name = m.group(1)
+        var_name = m.group(2)
+        if type_name.lower() not in _APEX_KEYWORDS:
+            result.setdefault(var_name, type_name)
+    return result
+
+
 # Minimum length and shape heuristics for a plausible Apex class name in _raw_calls.
 # Returns False for things like single-letter variables, all-caps constants,
 # or names that look like local variables rather than class references.
@@ -316,14 +356,13 @@ def extract_apex_class(path: Path) -> dict:
                     )
                 )
 
-        # DML → dml edges. The relation stays "dml" (unchanged) but each edge carries an
-        # "operation" field derived from the DML verb (insert→create / update→update /
-        # delete→delete / upsert / merge / undelete) so downstream can distinguish the
-        # kind of write. Native SF verbs (upsert/merge/undelete) are preserved rather than
-        # forced into CRUD. confidence stays INFERRED: the DML target is a variable name we
-        # cannot statically resolve to an object type — that honesty label must not change.
-        # Dedup is by (obj_var, operation) so a class that both inserts and updates the same
-        # object yields two edges, not one collapsed dml edge.
+        # DML → dml edges. Each edge carries an "operation" field (insert→create, etc.).
+        # Resolution order for the DML operand:
+        #   (a) look up the varName→Type map built by _extract_var_types;
+        #   (b) if the operand is already PascalCase and not a keyword, use it directly
+        #       (backward-compat: handles `insert Account;` style);
+        #   (c) otherwise skip — no edge for unresolvable variables (honesty).
+        # Dedup by (resolved_type, operation) so insert+update on the same object → two edges.
         _DML_VERB_TO_OP = {
             "insert": "create",
             "update": "update",
@@ -332,26 +371,35 @@ def extract_apex_class(path: Path) -> dict:
             "merge": "merge",
             "undelete": "undelete",
         }
+        var_types = _extract_var_types(text)
         seen_dml_ops: set[tuple[str, str]] = set()
         for dm in _DML_RE.finditer(text):
             operation = _DML_VERB_TO_OP[dm.group(1).lower()]
             obj_var = dm.group(2)
-            # obj_var is a variable name, not necessarily an object API name.
-            # We record it as INFERRED since we can't always resolve the type statically.
-            if obj_var.lower() not in _APEX_KEYWORDS and (obj_var, operation) not in seen_dml_ops:
-                seen_dml_ops.add((obj_var, operation))
-                # Only add the edge if it looks like a type name (capitalized) or known object
+            if obj_var.lower() in _APEX_KEYWORDS:
+                continue
+            resolved_type = var_types.get(obj_var)
+            if resolved_type is None:
+                # Fallback: operand is itself PascalCase — treat as the type name
                 if obj_var[0].isupper():
-                    edge = _make_edge(
-                        class_nid,
-                        object_id(obj_var),
-                        "dml",
-                        "INFERRED",
-                        str_path,
-                        confidence_score=0.7,
-                    )
-                    edge["operation"] = operation
-                    edges.append(edge)
+                    resolved_type = obj_var
+                else:
+                    continue  # lowercase variable with no declaration — skip
+            if resolved_type.lower() in _APEX_KEYWORDS:
+                continue  # primitive or system type — not a DML-able SObject
+            key = (resolved_type, operation)
+            if key not in seen_dml_ops:
+                seen_dml_ops.add(key)
+                edge = _make_edge(
+                    class_nid,
+                    object_id(resolved_type),
+                    "dml",
+                    "INFERRED",
+                    str_path,
+                    confidence_score=0.7,
+                )
+                edge["operation"] = operation
+                edges.append(edge)
 
         # Apex → Flow invocations via Flow.Interview.FlowName
         seen_flow_invokes: set[str] = set()

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/graphify_sf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify-sf
-Version: 0.3.4
+Version: 0.3.6
 Summary: Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required.
 Author: Ray Kuo
 License-Expression: MIT
@@ -25,6 +25,7 @@ License-File: LICENSE
 Requires-Dist: networkx>=3.0
 Requires-Dist: datasketch>=1.6
 Requires-Dist: rapidfuzz>=3.0
+Requires-Dist: pathspec>=0.12
 Requires-Dist: idna>=3.15
 Provides-Extra: leiden
 Requires-Dist: graspologic; python_version < "3.13" and extra == "leiden"
@@ -700,9 +701,33 @@ All configuration via environment variables:
 | `GRAPHIFY_SF_REBUILD_MEMORY_LIMIT_MB` | `` | Cap memory usage for background watch rebuilds (MB) |
 | `CLAUDE_CONFIG_DIR` | `~/.claude` | Override Claude Code config directory — only set if your Claude Code config lives at a non-standard path (company-managed dotfiles, CI, or multiple installations) |
 
-### `.graphifysfignore`
+### Ignoring files (`.gitignore`, `.forceignore`, `.graphifysfignore`)
 
-Place a `.graphifysfignore` file at your project root to exclude files/directories from scanning (same syntax as `.gitignore` glob patterns):
+By default graphify-sf **respects your project's `.gitignore` and `.forceignore`** so that
+deprecated metadata, `__tests__`, queues, editor/lint scaffolding, and build output don't become
+noise in the graph. Patterns use full gitignore semantics (negation `!keep`, anchored `/foo`,
+directory `foo/`, `**`), parsed with `pathspec` — the same way git and the `sf` CLI read them. The
+ignore files are found by walking **up** from the path you scan, so `graphify-sf force-app` still
+honors the `.gitignore`/`.forceignore` at your project root.
+
+After a scan, any skipped files are reported honestly:
+
+```
+[graphify-sf] 5573 metadata files found, 57 skipped
+[graphify-sf] skipped 57 files (.forceignore: 57) — use --include-ignored to include them
+```
+
+To scan **everything** regardless of `.gitignore`/`.forceignore` (e.g. you suspect a real metadata
+file was excluded):
+
+```bash
+graphify-sf <path> --include-ignored
+```
+
+#### `.graphifysfignore`
+
+For graphify-specific exclusions independent of git/SF, place a `.graphifysfignore` file at your
+project root (glob patterns, always applied):
 
 ```
 # Exclude test data

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/graphify_sf.egg-info/requires.txt

@@ -1,6 +1,7 @@
 networkx>=3.0
 datasketch>=1.6
 rapidfuzz>=3.0
+pathspec>=0.12
 idna>=3.15
 
 [all]

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphify-sf"
-version = "0.3.4"
+version = "0.3.6"
 description = "Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -33,6 +33,7 @@ dependencies = [
     "networkx>=3.0",
     "datasketch>=1.6",
     "rapidfuzz>=3.0",
+    "pathspec>=0.12",  # gitwildmatch parsing for .gitignore/.forceignore
     "idna>=3.15",  # CVE-2026-45409 fix — transitive via requests
 ]
 

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/tests/test_build.py

@@ -213,6 +213,88 @@ def test_deduplicate_removes_self_loops():
     assert len(deduped_edges) == 0
 
 
+# ---------------------------------------------------------------------------
+# Regression: dedup must NOT merge nodes of different sf_type (0.3.6 bug fix)
+# ---------------------------------------------------------------------------
+
+
+def test_dedup_does_not_merge_across_sf_type():
+    """A CustomObject and a CustomTab/PermissionSet that normalise to the same
+    label must remain SEPARATE nodes — previously they were conflated and the
+    object's edges were rewritten onto the wrong survivor."""
+    from graphify_sf.build import deduplicate_by_label
+
+    nodes = [
+        {"id": "object_supporterconnection__c", "label": "SupporterConnection__c", "sf_type": "CustomObject"},
+        {"id": "customtab_supporterconnection__c", "label": "SupporterConnection__c", "sf_type": "CustomTab"},
+    ]
+    edges = []
+    deduped_nodes, _ = deduplicate_by_label(nodes, edges)
+    ids = {n["id"] for n in deduped_nodes}
+    assert "object_supporterconnection__c" in ids
+    assert "customtab_supporterconnection__c" in ids
+    assert len(deduped_nodes) == 2, "different sf_type must not merge"
+
+
+def test_dedup_still_merges_same_sf_type_chunks():
+    """Same-type chunked duplicates (the intended case) still merge."""
+    from graphify_sf.build import deduplicate_by_label
+
+    nodes = [
+        {"id": "doc_readme", "label": "README", "sf_type": "Document"},
+        {"id": "doc_readme_c1", "label": "README", "sf_type": "Document"},  # chunk
+    ]
+    edges = [{"source": "doc_readme_c1", "target": "doc_readme", "relation": "references"}]
+    deduped_nodes, _ = deduplicate_by_label(nodes, edges)
+    assert len(deduped_nodes) == 1, "same-type chunk duplicates should merge"
+    assert deduped_nodes[0]["id"] == "doc_readme"
+
+
+def test_self_lookup_keeps_contains_edge():
+    """A self-referencing lookup field (object→field `contains` collides with
+    field→object `references` in the undirected simple graph) must keep the
+    `contains` ownership edge — it outranks `references`."""
+    from graphify_sf.build import build_from_json
+
+    extraction = {
+        "nodes": [
+            {"id": "object_account", "label": "Account", "sf_type": "CustomObject", "file_type": "object"},
+            {
+                "id": "field_account_parent__c",
+                "label": "Account.Parent__c",
+                "sf_type": "CustomField",
+                "file_type": "object",
+            },
+        ],
+        "edges": [
+            {"source": "object_account", "target": "field_account_parent__c", "relation": "contains"},
+            {"source": "field_account_parent__c", "target": "object_account", "relation": "references"},
+        ],
+    }
+    G = build_from_json(extraction)  # undirected (default)
+    assert G.has_edge("object_account", "field_account_parent__c")
+    assert G.get_edge_data("object_account", "field_account_parent__c")["relation"] == "contains"
+
+
+def test_contains_not_overwritten_regardless_of_edge_order():
+    """contains must win even when the weaker relation is added second."""
+    from graphify_sf.build import build_from_json
+
+    extraction = {
+        "nodes": [
+            {"id": "object_x", "label": "X", "sf_type": "CustomObject"},
+            {"id": "field_x_self__c", "label": "X.Self__c", "sf_type": "CustomField"},
+        ],
+        # references first, contains second
+        "edges": [
+            {"source": "field_x_self__c", "target": "object_x", "relation": "references"},
+            {"source": "object_x", "target": "field_x_self__c", "relation": "contains"},
+        ],
+    }
+    G = build_from_json(extraction)
+    assert G.get_edge_data("object_x", "field_x_self__c")["relation"] == "contains"
+
+
 # ---------------------------------------------------------------------------
 # _ensure_stub_nodes
 # ---------------------------------------------------------------------------

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/tests/test_detect.py

@@ -145,3 +145,99 @@ def test_detect_skipped_list(simple_detect_result):
     """Test that skipped list is present."""
     assert "skipped" in simple_detect_result
     assert isinstance(simple_detect_result["skipped"], list)
+
+
+# ---------------------------------------------------------------------------
+# .gitignore / .forceignore support (default-on, --include-ignored opt-out)
+# ---------------------------------------------------------------------------
+
+
+def _make_sfdx_tree(root: Path) -> None:
+    """Create a tiny SFDX tree: one kept class + one queue + a flow."""
+    classes = root / "force-app" / "main" / "default" / "classes"
+    classes.mkdir(parents=True)
+    (classes / "Keep.cls").write_text("public class Keep {}")
+    (classes / "Keep.cls-meta.xml").write_text(
+        '<?xml version="1.0"?><ApexClass xmlns="http://soap.sforce.com/2006/04/metadata"><apiVersion>59.0</apiVersion></ApexClass>'
+    )
+    queues = root / "force-app" / "main" / "default" / "queues"
+    queues.mkdir(parents=True)
+    (queues / "Sales.queue-meta.xml").write_text(
+        '<?xml version="1.0"?><Queue xmlns="http://soap.sforce.com/2006/04/metadata"><name>Sales</name></Queue>'
+    )
+    flows = root / "force-app" / "main" / "default" / "flows"
+    flows.mkdir(parents=True)
+    (flows / "Deprecated.flow-meta.xml").write_text(
+        '<?xml version="1.0"?><Flow xmlns="http://soap.sforce.com/2006/04/metadata"><label>Deprecated</label></Flow>'
+    )
+
+
+def test_forceignore_skips_files_by_default(tmp_path):
+    """.forceignore patterns skip matching files by default, with per-source count."""
+    from graphify_sf.detect import detect
+
+    _make_sfdx_tree(tmp_path)
+    (tmp_path / ".forceignore").write_text("**/queues/**\n**/Deprecated.flow-meta.xml\n")
+
+    res = detect(tmp_path)
+    all_files = [f for lst in res["files"].values() for f in lst]
+    assert not any("queues" in f for f in all_files), "queue file should be skipped"
+    assert not any("Deprecated" in f for f in all_files), "deprecated flow should be skipped"
+    assert any("Keep.cls" in f for f in all_files), "kept class must remain"
+    assert res["skipped_count"] >= 2
+    assert res["skipped_by_source"][".forceignore"] >= 2
+    assert res["respect_ignore"] is True
+
+
+def test_gitignore_skips_files_by_default(tmp_path):
+    """.gitignore patterns skip matching files by default."""
+    from graphify_sf.detect import detect
+
+    _make_sfdx_tree(tmp_path)
+    (tmp_path / ".gitignore").write_text("**/Deprecated.flow-meta.xml\n")
+
+    res = detect(tmp_path)
+    all_files = [f for lst in res["files"].values() for f in lst]
+    assert not any("Deprecated" in f for f in all_files)
+    assert res["skipped_by_source"][".gitignore"] >= 1
+
+
+def test_include_ignored_scans_everything(tmp_path):
+    """respect_ignore=False (--include-ignored) ignores .gitignore/.forceignore."""
+    from graphify_sf.detect import detect
+
+    _make_sfdx_tree(tmp_path)
+    (tmp_path / ".forceignore").write_text("**/queues/**\n**/Deprecated.flow-meta.xml\n")
+
+    res = detect(tmp_path, respect_ignore=False)
+    all_files = [f for lst in res["files"].values() for f in lst]
+    assert any("Deprecated" in f for f in all_files), "ignored flow must be included"
+    assert res["skipped_count"] == 0
+    assert res["respect_ignore"] is False
+
+
+def test_ignore_files_discovered_upward_from_subdir(tmp_path):
+    """Scanning a subdir still finds .forceignore at the project root (git-style upward walk)."""
+    from graphify_sf.detect import detect
+
+    _make_sfdx_tree(tmp_path)
+    # ignore file at repo root; scan the force-app subdir
+    (tmp_path / ".forceignore").write_text("**/Deprecated.flow-meta.xml\n")
+
+    res = detect(tmp_path / "force-app")
+    all_files = [f for lst in res["files"].values() for f in lst]
+    assert not any("Deprecated" in f for f in all_files), "root .forceignore must apply when scanning subdir"
+    assert res["skipped_by_source"][".forceignore"] >= 1
+
+
+def test_gitignore_negation_semantics(tmp_path):
+    """gitignore negation (!keep) is honored — fnmatch could not do this."""
+    from graphify_sf.detect import detect
+
+    _make_sfdx_tree(tmp_path)
+    # ignore all flows, then un-ignore the one we keep
+    (tmp_path / ".gitignore").write_text("**/*.flow-meta.xml\n!**/Deprecated.flow-meta.xml\n")
+
+    res = detect(tmp_path)
+    all_files = [f for lst in res["files"].values() for f in lst]
+    assert any("Deprecated" in f for f in all_files), "negated pattern must re-include the flow"

{graphify_sf-0.3.4 → graphify_sf-0.3.6}/tests/test_extract_apex.py

@@ -517,6 +517,126 @@ def test_extract_apex_trigger_fallback_uses_filename(tmp_path):
 # ---------------------------------------------------------------------------
 
 
+# ---------------------------------------------------------------------------
+# DML variable resolution (Approach A: varName → declared type)
+# ---------------------------------------------------------------------------
+
+
+def test_extract_apex_dml_lowercase_var_resolves_to_type(tmp_path):
+    """Core fix: `insert c;` where `Case c = new Case()` → dml edge to object_case."""
+    from graphify_sf.extract.apex import extract_apex_class
+
+    cls = tmp_path / "AfterHoursFallback.cls"
+    cls.write_text(
+        """\
+public class AfterHoursFallback {
+    public void run() {
+        Case c = new Case();
+        insert c;
+    }
+}
+"""
+    )
+
+    result = extract_apex_class(cls)
+    dml_edges = [e for e in result["edges"] if e.get("relation") == "dml"]
+    assert len(dml_edges) == 1
+    assert "case" in dml_edges[0]["target"].lower()
+    assert dml_edges[0]["operation"] == "create"
+    assert dml_edges[0]["confidence"] == "INFERRED"
+
+
+def test_extract_apex_dml_lowercase_var_insert_and_update_two_edges(tmp_path):
+    """Same lowercase variable insert + update → two dml edges (create, update)."""
+    from graphify_sf.extract.apex import extract_apex_class
+
+    cls = tmp_path / "CaseUpdater.cls"
+    cls.write_text(
+        """\
+public class CaseUpdater {
+    public void run() {
+        Case c = new Case();
+        insert c;
+        update c;
+    }
+}
+"""
+    )
+
+    result = extract_apex_class(cls)
+    dml_edges = [e for e in result["edges"] if e.get("relation") == "dml"]
+    case_edges = [e for e in dml_edges if "case" in e["target"].lower()]
+    assert len(case_edges) == 2
+    ops = {e["operation"] for e in case_edges}
+    assert ops == {"create", "update"}
+
+
+def test_extract_apex_dml_list_generic_resolves_inner_type(tmp_path):
+    """`List<Account> accs = ...; insert accs;` → dml edge to object_account."""
+    from graphify_sf.extract.apex import extract_apex_class
+
+    cls = tmp_path / "AccountBulkWriter.cls"
+    cls.write_text(
+        """\
+public class AccountBulkWriter {
+    public void run() {
+        List<Account> accs = new List<Account>();
+        insert accs;
+    }
+}
+"""
+    )
+
+    result = extract_apex_class(cls)
+    dml_edges = [e for e in result["edges"] if e.get("relation") == "dml"]
+    assert len(dml_edges) == 1
+    assert "account" in dml_edges[0]["target"].lower()
+    assert dml_edges[0]["operation"] == "create"
+
+
+def test_extract_apex_dml_method_param_resolves(tmp_path):
+    """Method parameter `Contact con` → `update con;` produces dml edge to object_contact."""
+    from graphify_sf.extract.apex import extract_apex_class
+
+    cls = tmp_path / "ContactSaver.cls"
+    cls.write_text(
+        """\
+public class ContactSaver {
+    public void save(Contact con) {
+        update con;
+    }
+}
+"""
+    )
+
+    result = extract_apex_class(cls)
+    dml_edges = [e for e in result["edges"] if e.get("relation") == "dml"]
+    assert len(dml_edges) == 1
+    assert "contact" in dml_edges[0]["target"].lower()
+    assert dml_edges[0]["operation"] == "update"
+
+
+def test_extract_apex_dml_unresolvable_var_skipped(tmp_path):
+    """A DML on a variable with no resolvable declaration emits NO dml edge."""
+    from graphify_sf.extract.apex import extract_apex_class
+
+    cls = tmp_path / "MysteryUpdater.cls"
+    cls.write_text(
+        """\
+public class MysteryUpdater {
+    public void run() {
+        update mystery;
+    }
+}
+"""
+    )
+
+    result = extract_apex_class(cls)
+    dml_edges = [e for e in result["edges"] if e.get("relation") == "dml"]
+    assert len(dml_edges) == 0
+    assert not any("mystery" in e.get("target", "").lower() for e in dml_edges)
+
+
 def test_extract_apex_raw_calls_filters_lowercase_variables(tmp_path):
     """Local variable method calls (e.g. myObj.doSomething()) are not stored as raw_calls,
     but PascalCase static/utility calls (e.g. AccountService.getInstance()) are kept."""