graphify-sf 0.4.0__tar.gz → 0.4.2__tar.gz

{graphify_sf-0.4.0 → graphify_sf-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify-sf
-Version: 0.4.0
+Version: 0.4.2
 Summary: Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required.
 Author: Ray Kuo
 License-Expression: MIT
@@ -17,55 +17,54 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 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"
+Requires-Dist: graspologic-native>=1.2.5; extra == "leiden"
 Provides-Extra: neo4j
 Requires-Dist: neo4j; extra == "neo4j"
 Provides-Extra: svg
 Requires-Dist: matplotlib; extra == "svg"
+Requires-Dist: scipy; extra == "svg"
 Provides-Extra: watch
 Requires-Dist: watchdog>=3.0; extra == "watch"
 Provides-Extra: mcp
-Requires-Dist: mcp>=1.0; extra == "mcp"
 Provides-Extra: claude
 Requires-Dist: anthropic>=0.30; extra == "claude"
 Provides-Extra: kimi
-Requires-Dist: openai>=1.0; extra == "kimi"
+Requires-Dist: openai>=1.58; extra == "kimi"
 Provides-Extra: gemini
-Requires-Dist: openai>=1.0; extra == "gemini"
+Requires-Dist: openai>=1.58; extra == "gemini"
 Provides-Extra: openai
-Requires-Dist: openai>=1.0; extra == "openai"
+Requires-Dist: openai>=1.58; extra == "openai"
 Provides-Extra: bedrock
-Requires-Dist: boto3>=1.28; extra == "bedrock"
+Requires-Dist: boto3>=1.34.116; extra == "bedrock"
 Provides-Extra: ollama
-Requires-Dist: openai>=1.0; extra == "ollama"
+Requires-Dist: openai>=1.58; extra == "ollama"
 Provides-Extra: llm
-Requires-Dist: openai>=1.0; extra == "llm"
+Requires-Dist: openai>=1.58; extra == "llm"
 Requires-Dist: anthropic>=0.30; extra == "llm"
 Provides-Extra: docs
-Requires-Dist: pypdf; extra == "docs"
+Requires-Dist: pypdf>=6.19; extra == "docs"
 Requires-Dist: python-docx; extra == "docs"
 Requires-Dist: openpyxl; extra == "docs"
 Provides-Extra: all
-Requires-Dist: graspologic; python_version < "3.13" and extra == "all"
+Requires-Dist: graspologic-native>=1.2.5; extra == "all"
 Requires-Dist: neo4j; extra == "all"
 Requires-Dist: matplotlib; extra == "all"
+Requires-Dist: scipy; extra == "all"
 Requires-Dist: watchdog>=3.0; extra == "all"
-Requires-Dist: mcp>=1.0; extra == "all"
-Requires-Dist: openai>=1.0; extra == "all"
+Requires-Dist: openai>=1.58; extra == "all"
 Requires-Dist: anthropic>=0.30; extra == "all"
-Requires-Dist: boto3>=1.28; extra == "all"
-Requires-Dist: pypdf; extra == "all"
+Requires-Dist: boto3>=1.34.116; extra == "all"
+Requires-Dist: pypdf>=6.19; extra == "all"
 Requires-Dist: python-docx; extra == "all"
 Requires-Dist: openpyxl; extra == "all"
 Provides-Extra: dev
@@ -301,15 +300,17 @@ The `--backend` flag adds an AI-powered extraction layer on top of the static XM
 
 ### Supported Backends
 
-| Backend | Flag | API Key env var | Estimated cost (1k files) |
-|---------|------|-----------------|--------------------------|
-| Claude | `--backend claude` | `ANTHROPIC_API_KEY` | ~$0.50 |
-| Gemini | `--backend gemini` | `GEMINI_API_KEY` or `GOOGLE_API_KEY` | ~$0.05 |
-| Kimi K2 | `--backend kimi` | `MOONSHOT_API_KEY` | ~$0.30 |
-| OpenAI | `--backend openai` | `OPENAI_API_KEY` | ~$0.20 |
-| AWS Bedrock | `--backend bedrock` | `AWS_PROFILE` / `AWS_REGION` | ~$0.50 |
-| Ollama (local) | `--backend ollama` | `OLLAMA_BASE_URL` | free |
-| Auto-detect | `--backend auto` | _(first found)_ | varies |
+| Backend | Flag | API Key env var | Default model | Price per 1M tokens (in / out) |
+|---------|------|-----------------|---------------|--------------------------------|
+| Claude | `--backend claude` | `ANTHROPIC_API_KEY` | `claude-sonnet-4-6` | $3.00 / $15.00 |
+| Gemini | `--backend gemini` | `GEMINI_API_KEY` or `GOOGLE_API_KEY` | `gemini-3.6-flash` | $0.75 / $3.75 |
+| Kimi | `--backend kimi` | `MOONSHOT_API_KEY` | `kimi-k3` | $3.00 / $15.00 |
+| OpenAI | `--backend openai` | `OPENAI_API_KEY` | `gpt-4.1-mini` | $0.40 / $1.60 |
+| AWS Bedrock | `--backend bedrock` | `AWS_PROFILE` / `AWS_REGION` | `us.anthropic.claude-sonnet-4-6` | $3.30 / $16.50 |
+| Ollama (local) | `--backend ollama` | `OLLAMA_BASE_URL` | `qwen2.5-coder:7b` | free |
+| Auto-detect | `--backend auto` | _(first found)_ | — | varies |
+
+Prices mirror `BACKENDS` in `graphify_sf/llm.py`, which the CLI also uses for its cost estimates. The estimates assume the default model, even if you override it. Gemini 3.x and Kimi K3 always reason, and their thinking tokens are billed as output. The Bedrock default is a US geo inference profile: outside US regions, set `GRAPHIFY_SF_BEDROCK_MODEL` (e.g. `eu.anthropic.claude-sonnet-4-6` or `global.anthropic.claude-sonnet-4-6`). Gemini, Kimi, OpenAI and Bedrock defaults can be overridden with the model variables below (Ollama via `OLLAMA_MODEL`). The Claude model is fixed, and the CLI has no `--model` flag.
 
 ### Install the SDK
 
@@ -333,12 +334,13 @@ pip install graphify-sf[llm]
 |----------|-------------|
 | `ANTHROPIC_API_KEY` | Claude API key |
 | `GEMINI_API_KEY` / `GOOGLE_API_KEY` | Gemini API key |
-| `MOONSHOT_API_KEY` | Kimi K2 API key |
+| `MOONSHOT_API_KEY` | Kimi API key |
 | `OPENAI_API_KEY` | OpenAI API key |
 | `AWS_PROFILE` / `AWS_REGION` | AWS credentials for Bedrock |
 | `OLLAMA_BASE_URL` | Ollama server URL (default: `http://localhost:11434/v1`) |
 | `OLLAMA_MODEL` | Ollama model name (default: `qwen2.5-coder:7b`) |
 | `GRAPHIFY_SF_GEMINI_MODEL` | Override Gemini model |
+| `GRAPHIFY_SF_KIMI_MODEL` | Override Kimi model (e.g. `kimi-k2.6`; K2.x runs with thinking disabled) |
 | `GRAPHIFY_SF_OPENAI_MODEL` | Override OpenAI model |
 | `GRAPHIFY_SF_BEDROCK_MODEL` | Override Bedrock model |
 | `GRAPHIFY_SF_MAX_OUTPUT_TOKENS` | Override max output tokens per LLM call |
@@ -572,6 +574,7 @@ graphify-sf serve --graph path/to/graph.json
 | `god_nodes` | Highest-degree nodes — the most central metadata in the org |
 | `list_communities` | All communities with their labels and member counts |
 | `get_community` | All members of a specific community (by id or label) |
+| `bfs_impact` | Bounded, direction-aware impact traversal (`forward`/`reverse`/`both`, `max_depth`, `relation_filter`, EXTRACTED-only unless `include_inferred`) |
 
 **Available resources** (via `resources/list` and `resources/read`):
 
@@ -742,7 +745,7 @@ force-app/archived/**
 ## Optional Extras
 
 ```bash
-# Better community detection (Leiden algorithm, Python < 3.13 only)
+# Better community detection (Leiden algorithm via graspologic-native)
 pip install graphify-sf[leiden]
 
 # Neo4j direct push support
@@ -754,7 +757,8 @@ pip install graphify-sf[svg]
 # Watchdog for efficient file-system events in watch mode
 pip install graphify-sf[watch]
 
-# MCP SDK (reserved for future native MCP SDK adoption)
+# MCP server — no extra needed (`graphify-sf serve` is self-contained);
+# kept as an empty alias so existing install commands still work
 pip install graphify-sf[mcp]
 
 # LLM semantic extraction — Claude
@@ -782,7 +786,7 @@ pip install graphify-sf[all]
 
 - Python 3.10+
 - No Salesforce CLI, no org connection, no API keys
-- Core dependencies: `networkx`, `datasketch`, `rapidfuzz`
+- Core dependencies: `networkx`, `pathspec`, `idna`
 
 ---
 
@@ -827,7 +831,7 @@ graphify_sf/
 ├── export.py       All export formats — HTML, SVG, Obsidian, GraphML, Cypher, wiki, ...
 ├── llm.py          LLM semantic extraction — 6 backends, SF-specific prompt, adaptive retry
 ├── watch.py        File-system watcher — fcntl rebuild lock, resource limits, callflow regen
-├── serve.py        MCP stdio server — 8 tools, 6 resources, blank-stdin filter
+├── serve.py        MCP stdio server — 9 tools, 6 resources, blank-stdin filter
 ├── cache.py        Per-file extraction cache — SHA-256 keyed, atomic writes
 ├── validate.py     Extraction schema validation — catches bad extractors before graph assembly
 ├── security.py     Input sanitization — sanitize_label, validate_graph_path

{graphify_sf-0.4.0 → graphify_sf-0.4.2}/README.md

@@ -225,15 +225,17 @@ The `--backend` flag adds an AI-powered extraction layer on top of the static XM
 
 ### Supported Backends
 
-| Backend | Flag | API Key env var | Estimated cost (1k files) |
-|---------|------|-----------------|--------------------------|
-| Claude | `--backend claude` | `ANTHROPIC_API_KEY` | ~$0.50 |
-| Gemini | `--backend gemini` | `GEMINI_API_KEY` or `GOOGLE_API_KEY` | ~$0.05 |
-| Kimi K2 | `--backend kimi` | `MOONSHOT_API_KEY` | ~$0.30 |
-| OpenAI | `--backend openai` | `OPENAI_API_KEY` | ~$0.20 |
-| AWS Bedrock | `--backend bedrock` | `AWS_PROFILE` / `AWS_REGION` | ~$0.50 |
-| Ollama (local) | `--backend ollama` | `OLLAMA_BASE_URL` | free |
-| Auto-detect | `--backend auto` | _(first found)_ | varies |
+| Backend | Flag | API Key env var | Default model | Price per 1M tokens (in / out) |
+|---------|------|-----------------|---------------|--------------------------------|
+| Claude | `--backend claude` | `ANTHROPIC_API_KEY` | `claude-sonnet-4-6` | $3.00 / $15.00 |
+| Gemini | `--backend gemini` | `GEMINI_API_KEY` or `GOOGLE_API_KEY` | `gemini-3.6-flash` | $0.75 / $3.75 |
+| Kimi | `--backend kimi` | `MOONSHOT_API_KEY` | `kimi-k3` | $3.00 / $15.00 |
+| OpenAI | `--backend openai` | `OPENAI_API_KEY` | `gpt-4.1-mini` | $0.40 / $1.60 |
+| AWS Bedrock | `--backend bedrock` | `AWS_PROFILE` / `AWS_REGION` | `us.anthropic.claude-sonnet-4-6` | $3.30 / $16.50 |
+| Ollama (local) | `--backend ollama` | `OLLAMA_BASE_URL` | `qwen2.5-coder:7b` | free |
+| Auto-detect | `--backend auto` | _(first found)_ | — | varies |
+
+Prices mirror `BACKENDS` in `graphify_sf/llm.py`, which the CLI also uses for its cost estimates. The estimates assume the default model, even if you override it. Gemini 3.x and Kimi K3 always reason, and their thinking tokens are billed as output. The Bedrock default is a US geo inference profile: outside US regions, set `GRAPHIFY_SF_BEDROCK_MODEL` (e.g. `eu.anthropic.claude-sonnet-4-6` or `global.anthropic.claude-sonnet-4-6`). Gemini, Kimi, OpenAI and Bedrock defaults can be overridden with the model variables below (Ollama via `OLLAMA_MODEL`). The Claude model is fixed, and the CLI has no `--model` flag.
 
 ### Install the SDK
 
@@ -257,12 +259,13 @@ pip install graphify-sf[llm]
 |----------|-------------|
 | `ANTHROPIC_API_KEY` | Claude API key |
 | `GEMINI_API_KEY` / `GOOGLE_API_KEY` | Gemini API key |
-| `MOONSHOT_API_KEY` | Kimi K2 API key |
+| `MOONSHOT_API_KEY` | Kimi API key |
 | `OPENAI_API_KEY` | OpenAI API key |
 | `AWS_PROFILE` / `AWS_REGION` | AWS credentials for Bedrock |
 | `OLLAMA_BASE_URL` | Ollama server URL (default: `http://localhost:11434/v1`) |
 | `OLLAMA_MODEL` | Ollama model name (default: `qwen2.5-coder:7b`) |
 | `GRAPHIFY_SF_GEMINI_MODEL` | Override Gemini model |
+| `GRAPHIFY_SF_KIMI_MODEL` | Override Kimi model (e.g. `kimi-k2.6`; K2.x runs with thinking disabled) |
 | `GRAPHIFY_SF_OPENAI_MODEL` | Override OpenAI model |
 | `GRAPHIFY_SF_BEDROCK_MODEL` | Override Bedrock model |
 | `GRAPHIFY_SF_MAX_OUTPUT_TOKENS` | Override max output tokens per LLM call |
@@ -496,6 +499,7 @@ graphify-sf serve --graph path/to/graph.json
 | `god_nodes` | Highest-degree nodes — the most central metadata in the org |
 | `list_communities` | All communities with their labels and member counts |
 | `get_community` | All members of a specific community (by id or label) |
+| `bfs_impact` | Bounded, direction-aware impact traversal (`forward`/`reverse`/`both`, `max_depth`, `relation_filter`, EXTRACTED-only unless `include_inferred`) |
 
 **Available resources** (via `resources/list` and `resources/read`):
 
@@ -666,7 +670,7 @@ force-app/archived/**
 ## Optional Extras
 
 ```bash
-# Better community detection (Leiden algorithm, Python < 3.13 only)
+# Better community detection (Leiden algorithm via graspologic-native)
 pip install graphify-sf[leiden]
 
 # Neo4j direct push support
@@ -678,7 +682,8 @@ pip install graphify-sf[svg]
 # Watchdog for efficient file-system events in watch mode
 pip install graphify-sf[watch]
 
-# MCP SDK (reserved for future native MCP SDK adoption)
+# MCP server — no extra needed (`graphify-sf serve` is self-contained);
+# kept as an empty alias so existing install commands still work
 pip install graphify-sf[mcp]
 
 # LLM semantic extraction — Claude
@@ -706,7 +711,7 @@ pip install graphify-sf[all]
 
 - Python 3.10+
 - No Salesforce CLI, no org connection, no API keys
-- Core dependencies: `networkx`, `datasketch`, `rapidfuzz`
+- Core dependencies: `networkx`, `pathspec`, `idna`
 
 ---
 
@@ -751,7 +756,7 @@ graphify_sf/
 ├── export.py       All export formats — HTML, SVG, Obsidian, GraphML, Cypher, wiki, ...
 ├── llm.py          LLM semantic extraction — 6 backends, SF-specific prompt, adaptive retry
 ├── watch.py        File-system watcher — fcntl rebuild lock, resource limits, callflow regen
-├── serve.py        MCP stdio server — 8 tools, 6 resources, blank-stdin filter
+├── serve.py        MCP stdio server — 9 tools, 6 resources, blank-stdin filter
 ├── cache.py        Per-file extraction cache — SHA-256 keyed, atomic writes
 ├── validate.py     Extraction schema validation — catches bad extractors before graph assembly
 ├── security.py     Input sanitization — sanitize_label, validate_graph_path

{graphify_sf-0.4.0 → graphify_sf-0.4.2}/graphify_sf/__main__.py

@@ -37,6 +37,78 @@ def _load_graph_from_json(path: Path):
         return _jg.node_link_graph(raw), raw
 
 
+def _load_graph_json_raw(path: Path) -> dict:
+    """Load a graph.json's raw ``nodes``/``links`` lists (no NetworkX collapse).
+
+    Returns ``{"nodes": [...], "links": [...]}`` — empty lists if the file is
+    missing or unreadable. The merge paths use this instead of a ``nx.Graph()``
+    union so same-direction parallel edges survive until the multigraph build.
+    """
+    if not path.exists():
+        return {"nodes": [], "links": []}
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+        if "links" not in raw and "edges" in raw:
+            raw["links"] = raw["edges"]
+        return raw
+    except Exception:
+        return {"nodes": [], "links": []}
+
+
+_UNION_EDGE_IGNORED_FIELDS = frozenset({"key", "source_file"})
+
+
+def _union_edge_identity(edge: dict) -> str:
+    """Canonical dedup identity for a link during union.
+
+    Hashes the full edge dict minus the per-graph fields that legitimately vary
+    across inputs (``key`` — each source graph numbers its own parallel edges
+    from 0; ``source_file`` — an absolute path unique to the machine that built
+    that graph). Every other field participates, so edges that differ only in
+    ``operation`` (e.g. ``dml`` create vs. update on the same source→target
+    pair, which ``extract/apex.py`` and ``extract/flow.py`` deliberately emit as
+    distinct edges) are kept apart, while genuinely-identical duplicates (the
+    common base/ours/theirs 3-way case) still collapse to one.
+    """
+    identity = {k: v for k, v in edge.items() if k not in _UNION_EDGE_IGNORED_FIELDS}
+    return json.dumps(identity, sort_keys=True, default=str)
+
+
+def _union_graph_json(datas: list[dict]) -> tuple[list[dict], list[dict]]:
+    """Union raw graph.json node/link lists across multiple graphs.
+
+    Nodes are deduped by ``id`` (first occurrence wins). Links are unioned and
+    deduped on a canonical hash of the full edge dict (minus the per-graph
+    ``key``/``source_file`` fields), so distinct parallel edges are ALL
+    preserved — both those differing in ``relation`` (e.g. ``queries`` + ``dml``
+    on the same pair) and those differing only in ``operation`` (e.g. two
+    ``dml`` edges, one create + one update, on the same pair). A plain
+    ``nx.Graph()`` union would collapse the former, and a coarse
+    ``(source, target, relation)`` key would collapse the latter, before the
+    multigraph build ever runs. Genuinely-identical duplicate edges (the
+    base/ours/theirs 3-way merge case) still coalesce to one.
+    """
+    all_nodes: dict[str, dict] = {}
+    all_edges: list[dict] = []
+    seen_edges: set[str] = set()
+    for data in datas:
+        for node in data.get("nodes", []):
+            nid = node.get("id", "")
+            if nid and nid not in all_nodes:
+                all_nodes[nid] = node
+        links_key = "links" if "links" in data else "edges"
+        for edge in data.get(links_key, []):
+            identity = _union_edge_identity(edge)
+            if identity not in seen_edges:
+                seen_edges.add(identity)
+                # Drop the exported per-graph "key" — each source graph numbers its
+                # own parallel edges from 0, so two distinct relations on the same
+                # pair both arrive as key=0 and would collapse on rebuild. Stripping
+                # it lets the MultiDiGraph assign fresh keys per parallel edge.
+                all_edges.append({k: v for k, v in edge.items() if k != "key"})
+    return list(all_nodes.values()), all_edges
+
+
 def _derive_community_labels(G, communities: dict) -> dict[int, str]:
     """Derive community label from the highest-degree non-method node."""
     labels: dict[int, str] = {}
@@ -184,6 +256,7 @@ def _run_pipeline(
     backend: str | None = None,
     token_budget: int = 40_000,
     respect_ignore: bool = True,
+    verbose: bool = False,
 ) -> None:
     """Full pipeline: detect → extract → [LLM] → build → cluster → report → export."""
     from graphify_sf.analyze import god_nodes, suggest_questions, surprising_connections
@@ -241,7 +314,9 @@ def _run_pipeline(
         _run_llm_extraction(target, detection, extraction, backend, token_budget, token_cost)
 
     # Dedup by label
+    n_extracted = len(extraction["nodes"])
     nodes, edges = deduplicate_by_label(extraction["nodes"], extraction["edges"])
+    n_deduped = len(nodes)
 
     new_extraction = {"nodes": nodes, "edges": edges}
 
@@ -254,6 +329,34 @@ def _run_pipeline(
 
     print(f"[graphify-sf] graph: {G.number_of_nodes()} nodes, {G.number_of_edges()} edges")
 
+    if verbose:
+        # Honest node-drop accounting (closes the unanswered BUGS_FOUND question:
+        # "N nodes dropped between extract and build — dedup or dangling pruning?").
+        # Real pipeline stages, verified against build.py:
+        #   * deduplicate_by_label MERGES same-(sf_type,label) nodes → removes nodes
+        #   * build_from_json ADDS stub nodes for prefix-matched missing edge
+        #     endpoints, and PRUNES dangling EDGES (edges to still-absent nodes) —
+        #     it removes edges, never nodes.
+        # "Build-added stubs" are counted as final node ids absent from the deduped
+        # set (NOT the `stub` attribute, which the extractors also set on stubs they
+        # inject before dedup). For a fresh build: final == deduped + build_stubs.
+        n_final = G.number_of_nodes()
+        deduped_ids = {n["id"] for n in nodes if isinstance(n, dict) and "id" in n}
+        # In incremental mode G is merged with the ENTIRE prior graph.json, so nodes
+        # retained unchanged from that prior run are absent from this run's own
+        # deduped_ids and would be miscounted as build-injected stubs. Gate stub
+        # reporting to the fresh-build path, same as n_pruned_edges below.
+        n_build_stubs = sum(1 for nid in G.nodes() if nid not in deduped_ids) if not incremental else None
+        stub_str = "n/a (incremental merge)" if n_build_stubs is None else f"+{n_build_stubs} stub"
+        n_pruned_edges = max(0, len(edges) - G.number_of_edges()) if not incremental else None
+        pruned_str = "n/a (incremental merge)" if n_pruned_edges is None else str(n_pruned_edges)
+        print(
+            f"[graphify-sf] node accounting: {n_extracted} extracted "
+            f"→ {n_deduped} deduped-by-label ({n_extracted - n_deduped} merged) "
+            f"→ {stub_str} → {n_final} final nodes "
+            f"({pruned_str} dangling edge(s) pruned)"
+        )
+
     if G.number_of_nodes() == 0:
         print("[graphify-sf] error: graph is empty after extraction", file=sys.stderr)
         sys.exit(1)
@@ -500,15 +603,20 @@ def _cmd_path(source_label: str, target_label: str, graph_path: Path) -> None:
         print(f"No path found between '{source_label}' and '{target_label}'.")
         sys.exit(0)
 
-    from graphify_sf.build import edge_data
+    from graphify_sf.build import edge_datas
 
     hops = len(path_nodes) - 1
     segments = []
     for i in range(len(path_nodes) - 1):
         u, v = path_nodes[i], path_nodes[i + 1]
-        edata = edge_data(G, u, v)
-        rel = edata.get("relation", "")
-        conf = edata.get("confidence", "")
+        # MultiDiGraph: a hop may carry several parallel edges (e.g. queries +
+        # dml). Show every relation on the hop, not an arbitrary first one.
+        edatas = edge_datas(G, u, v)
+        rels = [ed.get("relation", "") for ed in edatas] or [""]
+        confs = [ed.get("confidence", "") for ed in edatas] or [""]
+        rel = "/".join(r for r in rels if r) or (rels[0] if rels else "")
+        conf_parts = [c for c in confs if c]
+        conf = "/".join(dict.fromkeys(conf_parts)) if conf_parts else ""
         conf_str = f" [{conf}]" if conf else ""
         if i == 0:
             segments.append(G.nodes[u].get("label", u))
@@ -733,23 +841,23 @@ def _cmd_merge_graphs(graph_paths: list[Path], out_path: Path, *, no_viz: bool =
             print(f"error: graph not found: {gp}", file=sys.stderr)
             sys.exit(1)
 
-    # Load all graphs
-    import networkx as nx
-
-    merged = nx.Graph()
+    # Load all graphs as raw JSON node/link lists and union them WITHOUT going
+    # through a plain nx.Graph(), which would collapse same-direction parallel
+    # edges before the multigraph-aware build ever runs. Mirrors the edge-safe
+    # union already used by _cmd_merge_driver.
+    raw_datas = []
     for gp in graph_paths:
         print(f"[graphify-sf] loading {gp}...")
-        G_i, raw_i = _load_graph_from_json(gp)
-        print(f"  {G_i.number_of_nodes()} nodes, {G_i.number_of_edges()} edges")
-        merged.update(G_i)
+        raw_i = _load_graph_json_raw(gp)
+        print(f"  {len(raw_i.get('nodes', []))} nodes, {len(raw_i.get('links', raw_i.get('edges', [])))} edges")
+        raw_datas.append(raw_i)
 
-    print(f"[graphify-sf] merged: {merged.number_of_nodes()} nodes, {merged.number_of_edges()} edges (before dedup)")
+    nodes_data, edges_data = _union_graph_json(raw_datas)
+    print(f"[graphify-sf] merged: {len(nodes_data)} nodes, {len(edges_data)} edges (before dedup)")
 
-    # Dedup by label
-    nodes_data = [{"id": nid, **data} for nid, data in merged.nodes(data=True)]
-    edges_data = [{"source": u, "target": v, **data} for u, v, data in merged.edges(data=True)]
+    # Dedup by label, then build the multigraph so parallel edges survive.
     nodes_dedup, edges_dedup = deduplicate_by_label(nodes_data, edges_data)
-    G = build_from_json({"nodes": nodes_dedup, "edges": edges_dedup})
+    G = build_from_json({"nodes": nodes_dedup, "edges": edges_dedup}, multigraph=True)
 
     print(f"[graphify-sf] after dedup: {G.number_of_nodes()} nodes, {G.number_of_edges()} edges")
 
@@ -823,44 +931,13 @@ def _cmd_merge_driver(base: Path, ours: Path, theirs: Path) -> None:
     from graphify_sf.cluster import cluster
     from graphify_sf.export import to_json
 
-    def _load(p: Path):
-        if not p.exists():
-            return {"nodes": [], "links": []}
-        try:
-            raw = json.loads(p.read_text(encoding="utf-8"))
-            if "links" not in raw and "edges" in raw:
-                raw["links"] = raw["edges"]
-            return raw
-        except Exception:
-            return {"nodes": [], "links": []}
-
-    base_data = _load(base)
-    our_data = _load(ours)
-    their_data = _load(theirs)
-
-    # Union all nodes and edges by id
-    all_nodes: dict[str, dict] = {}
-    all_edges: list[dict] = []
-    seen_edges: set[tuple] = set()
-
-    for data in (base_data, our_data, their_data):
-        for node in data.get("nodes", []):
-            nid = node.get("id", "")
-            if nid and nid not in all_nodes:
-                all_nodes[nid] = node
-        links_key = "links" if "links" in data else "edges"
-        for edge in data.get(links_key, []):
-            src = edge.get("source", "")
-            tgt = edge.get("target", "")
-            rel = edge.get("relation", "")
-            key = (src, tgt, rel)
-            if key not in seen_edges:
-                seen_edges.add(key)
-                all_edges.append(edge)
-
-    extraction = {"nodes": list(all_nodes.values()), "edges": all_edges}
-    nodes_dedup, edges_dedup = deduplicate_by_label(extraction["nodes"], extraction["edges"])
-    G = build_from_json({"nodes": nodes_dedup, "edges": edges_dedup})
+    # Union raw node/link lists (dedup nodes by id, links by (src,tgt,rel)) so
+    # parallel edges survive; see _union_graph_json.
+    all_nodes, all_edges = _union_graph_json(
+        [_load_graph_json_raw(base), _load_graph_json_raw(ours), _load_graph_json_raw(theirs)]
+    )
+    nodes_dedup, edges_dedup = deduplicate_by_label(all_nodes, all_edges)
+    G = build_from_json({"nodes": nodes_dedup, "edges": edges_dedup}, multigraph=True)
     communities = cluster(G)
     to_json(G, communities, str(ours), force=True)
     print(f"[graphify-sf] merge-driver: merged {G.number_of_nodes()} nodes, {G.number_of_edges()} edges → {ours}")
@@ -1578,6 +1655,7 @@ def main() -> None:
         print("    --update                         incremental update (re-extract changed files)")
         print("    --directed                       build directed graph")
         print("    --no-viz                         skip graph.html generation")
+        print("    --verbose, -v                    print node-drop accounting (extract→dedup→build)")
         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)")
@@ -1947,6 +2025,7 @@ def main() -> None:
         backend: str | None = None
         token_budget = 40_000
         respect_ignore = True
+        verbose = False
 
         i = 1
         while i < len(args):
@@ -1966,6 +2045,9 @@ def main() -> None:
             elif a == "--no-viz":
                 no_viz = True
                 i += 1
+            elif a in ("--verbose", "-v"):
+                verbose = True
+                i += 1
             elif a == "--force":
                 force = True
                 i += 1
@@ -2005,6 +2087,7 @@ def main() -> None:
             backend=backend,
             token_budget=token_budget,
             respect_ignore=respect_ignore,
+            verbose=verbose,
         )
         return
 

{graphify_sf-0.4.0 → graphify_sf-0.4.2}/graphify_sf/_bundled_skill.md

@@ -20,7 +20,7 @@ Turn any Salesforce SFDX project into a navigable knowledge graph with community
 /graphify-sf <path> --force                           # overwrite graph.json even if new graph is smaller
 /graphify-sf <path> --max-workers N                   # parallel extraction worker count
 /graphify-sf <path> --backend claude                  # add AI semantic layer (business rules, dead metadata)
-/graphify-sf <path> --backend gemini                  # Gemini backend (cheapest, ~$0.05/1k files)
+/graphify-sf <path> --backend gemini                  # Gemini backend
 /graphify-sf <path> --backend auto                    # auto-detect backend from available API keys
 /graphify-sf <path> --backend claude --token-budget 20000  # smaller chunks for large orgs
 /graphify-sf cluster-only <path>                      # rerun clustering on existing graph

{graphify_sf-0.4.0 → graphify_sf-0.4.2}/graphify_sf/cluster.py

@@ -1,10 +1,10 @@
 """Community detection on NetworkX graphs.
 
-Uses Leiden (graspologic) if available, falls back to Louvain (networkx).
+Uses Leiden (graspologic-native) if available, falls back to Louvain (networkx).
 Splits oversized communities. Returns cohesion scores.
 
-Adapted from Graphify's cluster.py — logic is identical; just updated
-module name in docstrings.
+Adapted from Graphify's cluster.py; the Leiden path has since diverged
+(graspologic-native engine, parallel-edge aggregation, deterministic labels).
 """
 
 from __future__ import annotations
@@ -22,23 +22,60 @@ def _suppress_output():
     return contextlib.redirect_stdout(io.StringIO())
 
 
+def _leiden_edge_list(G: nx.Graph) -> list[tuple[str, str, float]]:
+    """Collapse G into one weighted edge per unordered node pair, keyed by str ids.
+
+    graspologic-native keeps only the first weight it sees for a pair (later
+    duplicates, including the reversed pair, are dropped), so parallel edges are
+    summed here — the same treatment Louvain gives multigraphs. Self-loops are
+    skipped. Sorted, so the result never depends on G's iteration order (which,
+    for small networkx subgraph views, follows Python's randomized str hashing).
+    """
+    weights: dict[tuple[str, str], float] = {}
+    for u, v, w in G.edges(data="weight", default=1.0):
+        su, sv = str(u), str(v)
+        if su == sv:
+            continue
+        pair = (su, sv) if su < sv else (sv, su)
+        weights[pair] = weights.get(pair, 0.0) + float(w)
+    return sorted((a, b, w) for (a, b), w in weights.items())
+
+
 def _partition(G: nx.Graph) -> dict[str, int]:
     """Run community detection. Returns {node_id: community_id}.
 
-    Tries Leiden (graspologic) first — best quality.
-    Falls back to Louvain (built into networkx) if graspologic is not installed.
+    Tries Leiden (graspologic-native) first — best quality.
+    Falls back to Louvain (built into networkx) if graspologic-native is not installed.
     """
     try:
-        from graspologic.partition import leiden
-
-        old_stderr = sys.stderr
-        try:
-            sys.stderr = io.StringIO()
-            with _suppress_output():
-                result = leiden(G)
-        finally:
-            sys.stderr = old_stderr
-        return result
+        from graspologic_native import leiden
+
+        edges = _leiden_edge_list(G)
+        native: dict[str, int] = {}
+        if edges:
+            old_stderr = sys.stderr
+            try:
+                sys.stderr = io.StringIO()
+                with _suppress_output():
+                    _, native = leiden(
+                        edges=edges,
+                        resolution=1.0,
+                        randomness=0.001,
+                        iterations=1,
+                        use_modularity=True,
+                        seed=42,
+                        trials=1,
+                    )
+            finally:
+                sys.stderr = old_stderr
+        # Relabel in sorted-id order: the engine's own labels (and dict order) vary
+        # between runs even with a fixed seed, which would reshuffle cluster()'s
+        # size-tie ordering. Nodes whose only edges are self-loops never reach the
+        # engine and get a community of their own.
+        labels: dict[object, int] = {}
+        return {
+            n: labels.setdefault(native.get(str(n), ("self-loop", n)), len(labels)) for n in sorted(G.nodes(), key=str)
+        }
     except ImportError:
         pass
 

{graphify_sf-0.4.0 → graphify_sf-0.4.2}/graphify_sf/export.py

@@ -1025,7 +1025,7 @@ def to_svg(
 ) -> None:
     """Export the graph as an SVG image using matplotlib + networkx layout.
 
-    Requires: pip install graphify-sf[svg]  (installs matplotlib)
+    Requires: pip install graphify-sf[svg]  (installs matplotlib + scipy)
 
     Args:
         G: NetworkX graph.