graphifyy 0.9.4__tar.gz → 0.9.6__tar.gz

{graphifyy-0.9.4/graphifyy.egg-info → graphifyy-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphifyy
-Version: 0.9.4
+Version: 0.9.6
 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: MIT License
         
@@ -151,7 +151,7 @@ Dynamic: license-file
   <a href="https://pypi.org/project/graphifyy/"><img src="https://img.shields.io/pypi/v/graphifyy" alt="PyPI"/></a>
   <a href="https://pepy.tech/project/graphifyy"><img src="https://img.shields.io/pepy/dt/graphifyy?color=blue&label=downloads" alt="Downloads"/></a>
   <a href="https://github.com/sponsors/safishamsi"><img src="https://img.shields.io/badge/sponsor-safishamsi-ea4aaa?logo=github-sponsors" alt="Sponsor"/></a>
-  <a href="https://www.linkedin.com/in/safi-shamsi"><img src="https://img.shields.io/badge/LinkedIn-Safi%20Shamsi-0077B5?logo=linkedin" alt="LinkedIn"/></a>
+  <a href="https://www.linkedin.com/company/graphify-labs"><img src="https://img.shields.io/badge/LinkedIn-Graphify%20Labs-0077B5?logo=linkedin" alt="LinkedIn"/></a>
   <a href="https://x.com/graphifyy"><img src="https://img.shields.io/badge/X-graphifyy-000000?logo=x&logoColor=white" alt="X"/></a>
 </p>
 

{graphifyy-0.9.4 → graphifyy-0.9.6}/README.md

@@ -14,7 +14,7 @@
   <a href="https://pypi.org/project/graphifyy/"><img src="https://img.shields.io/pypi/v/graphifyy" alt="PyPI"/></a>
   <a href="https://pepy.tech/project/graphifyy"><img src="https://img.shields.io/pepy/dt/graphifyy?color=blue&label=downloads" alt="Downloads"/></a>
   <a href="https://github.com/sponsors/safishamsi"><img src="https://img.shields.io/badge/sponsor-safishamsi-ea4aaa?logo=github-sponsors" alt="Sponsor"/></a>
-  <a href="https://www.linkedin.com/in/safi-shamsi"><img src="https://img.shields.io/badge/LinkedIn-Safi%20Shamsi-0077B5?logo=linkedin" alt="LinkedIn"/></a>
+  <a href="https://www.linkedin.com/company/graphify-labs"><img src="https://img.shields.io/badge/LinkedIn-Graphify%20Labs-0077B5?logo=linkedin" alt="LinkedIn"/></a>
   <a href="https://x.com/graphifyy"><img src="https://img.shields.io/badge/X-graphifyy-000000?logo=x&logoColor=white" alt="X"/></a>
 </p>
 

{graphifyy-0.9.4 → graphifyy-0.9.6}/graphify/__main__.py

@@ -3550,10 +3550,59 @@ def main() -> None:
             except Exception:
                 existing_labels = {}
         if labels_path.exists() and not force_relabel:
-            try:
-                labels = existing_labels
-            except Exception:
-                labels = {cid: f"Community {cid}" for cid in communities}
+            # Reuse saved labels, but don't blindly trust them: the graph may have
+            # been re-scoped/re-clustered since labeling, in which case a cid now
+            # covers a DIFFERENT community and its old (LLM) name is wrong (#label-stale).
+            # Validate each community against the membership signature saved beside the
+            # labels; any community that changed (or has no saved label) is renamed by
+            # its current hub — deterministic and correct-by-construction — and the user
+            # is told to `graphify label` for fresh LLM names. Unchanged communities keep
+            # their saved label. When no signature sidecar exists (labels predate this),
+            # fall back to hub-filling only the communities missing a label.
+            from graphify.cluster import community_member_sigs, label_communities_by_hub
+            sig_path = labels_path.parent / (labels_path.name + ".sig")
+            saved_sigs: dict[int, str] = {}
+            if sig_path.exists():
+                try:
+                    saved_sigs = {
+                        int(k): v for k, v in
+                        json.loads(sig_path.read_text(encoding="utf-8")).items()
+                        if isinstance(v, str)
+                    }
+                except Exception:
+                    saved_sigs = {}
+            cur_sigs = community_member_sigs(communities)
+            count_mismatch = len(existing_labels) != len(communities)
+            labels = {}
+            hub_labels: dict[int, str] | None = None
+            changed = 0
+            for cid in communities:
+                have_label = cid in existing_labels
+                if saved_sigs:
+                    # Precise: the membership signature tells us if this exact
+                    # community changed since it was labeled.
+                    fresh = have_label and saved_sigs.get(cid) == cur_sigs.get(cid)
+                else:
+                    # No signature sidecar (labels predate it). A differing community
+                    # COUNT means the labels describe a different clustering, so a cid's
+                    # old label can't be trusted; equal count is the best "same" signal.
+                    fresh = have_label and not count_mismatch
+                if fresh:
+                    labels[cid] = existing_labels[cid]
+                else:
+                    if hub_labels is None:
+                        hub_labels = label_communities_by_hub(G, communities)
+                    labels[cid] = hub_labels[cid]
+                    if have_label:
+                        changed += 1
+            if changed:
+                print(
+                    f"[graphify] community set changed since labeling "
+                    f"({len(existing_labels)} saved labels, {len(communities)} communities now; "
+                    f"renamed {changed} community(ies) by their hub). "
+                    f"Run `graphify label` to refresh names with the LLM.",
+                    file=sys.stderr,
+                )
         elif no_label and not force_relabel:
             labels = {cid: f"Community {cid}" for cid in communities}
         else:
@@ -3606,8 +3655,24 @@ def main() -> None:
         stages.mark("report")
         from graphify.export import backup_if_protected as _backup
         _backup(out)
+        analysis = {
+            "communities": {str(k): v for k, v in communities.items()},
+            "cohesion": {str(k): v for k, v in cohesion.items()},
+            "gods": gods,
+            "surprises": surprises,
+            "questions": questions,
+        }
+        (out / ".graphify_analysis.json").write_text(
+            json.dumps(analysis, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
         to_json(G, communities, str(out / "graph.json"), community_labels=labels)
         labels_path.write_text(json.dumps({str(k): v for k, v in labels.items()}, ensure_ascii=False), encoding="utf-8")
+        # Membership signatures beside the labels so a later cluster-only can detect
+        # which communities changed and avoid reusing a stale label (see reuse above).
+        from graphify.cluster import community_member_sigs as _cms
+        (labels_path.parent / (labels_path.name + ".sig")).write_text(
+            json.dumps({str(k): v for k, v in _cms(communities).items()}), encoding="utf-8")
 
         # Mirror watch.py pattern: gate to_html so core outputs (graph.json +
         # GRAPH_REPORT.md) always land. Honor --no-viz explicitly; otherwise
@@ -3858,7 +3923,14 @@ def main() -> None:
         # may be a MultiGraph and another a Graph.  Normalise everything to Graph
         # (the graphify default) by converting MultiGraphs with nx.Graph().
         def _to_simple(g: "_nx.Graph") -> "_nx.Graph":
-            if isinstance(g, _nx.MultiGraph):
+            # nx.compose requires every graph to be the same type. Inputs may
+            # disagree on BOTH axes — directed vs undirected, and multi vs simple
+            # — because per-repo graph.json files are written by different extract
+            # paths at different times. Normalise everything to a plain undirected
+            # Graph (the merged cross-repo view is undirected anyway), which covers
+            # DiGraph / MultiGraph / MultiDiGraph. Without this a directed input
+            # crashed compose with "All graphs must be directed or undirected" (#1606).
+            if type(g) is not _nx.Graph:
                 return _nx.Graph(g)
             return g
         merged = _nx.Graph()

{graphifyy-0.9.4 → graphifyy-0.9.6}/graphify/analyze.py

@@ -23,7 +23,7 @@ _BUILTIN_NOISE_LABELS = frozenset({
 # Language families — extensions sharing a runtime can legitimately call each other
 _LANG_FAMILY: dict[str, str] = {
     **{e: "python" for e in (".py", ".pyw")},
-    **{e: "js" for e in (".js", ".jsx", ".mjs", ".ejs", ".ts", ".tsx", ".vue", ".svelte")},
+    **{e: "js" for e in (".js", ".jsx", ".mjs", ".ejs", ".ts", ".tsx", ".mts", ".cts", ".vue", ".svelte")},
     **{e: "go" for e in (".go",)},
     **{e: "rust" for e in (".rs",)},
     **{e: "jvm" for e in (".java", ".kt", ".kts", ".scala")},

{graphifyy-0.9.4 → graphifyy-0.9.6}/graphify/build.py

@@ -258,6 +258,11 @@ def _semantic_id_remap(nodes: list, root: str | None) -> dict:
         rel = Path(sf_norm)
         if rel.is_absolute():
             continue  # can't relativize (no/failed root) — leave id untouched
+        if not rel.name:
+            # source_file equals the scan root, so _norm_source_file relativized it
+            # to Path('.') — a project-level node with no per-file identity to remap.
+            # Leave its id untouched (and avoid _file_stem's empty-name crash, #1618).
+            continue
         new_stem = make_id(_file_stem(rel))
         if not new_stem:
             continue
@@ -305,6 +310,8 @@ def graph_has_legacy_ids(nodes: list, root: str | Path | None = None, sample: in
         rel = Path(_norm_source_file(str(sf), _r) or str(sf))
         if rel.is_absolute():
             continue
+        if not rel.name:
+            continue  # source_file == scan root -> Path('.'), no file stem (#1618)
         new_stem = make_id(_file_stem(rel))
         if not new_stem:
             continue
@@ -577,7 +584,7 @@ def build_from_json(extraction: dict, *, directed: bool = False, root: str | Pat
             _LANG_FAMILY: dict[str, str] = {
                 ".py": "py", ".pyi": "py",
                 ".js": "js", ".mjs": "js", ".cjs": "js", ".jsx": "js",
-                ".ts": "js", ".tsx": "js",
+                ".ts": "js", ".tsx": "js", ".mts": "js", ".cts": "js",
                 ".go": "go", ".rs": "rs",
                 ".java": "jvm", ".kt": "jvm", ".scala": "jvm", ".groovy": "jvm",
                 # C, C++, and ObjC interoperate within one compilation unit: a method

{graphifyy-0.9.4 → graphifyy-0.9.6}/graphify/cluster.py

@@ -110,6 +110,27 @@ def label_communities_by_hub(
     return labels
 
 
+def community_member_sigs(communities: dict[int, list[str]]) -> dict[int, str]:
+    """Per-community membership fingerprints: ``{cid: sha256(sorted member ids)}``.
+
+    Persisted next to ``.graphify_labels.json`` so a later ``cluster-only`` can tell
+    which communities actually changed since labeling. A cid whose members no longer
+    hash the same is a different community — reusing its old (LLM) label there is the
+    "stale label after re-scoping" bug this guards against. Deterministic; independent
+    of cid index, node order, and machine.
+    """
+    import hashlib
+
+    sigs: dict[int, str] = {}
+    for cid, members in communities.items():
+        h = hashlib.sha256()
+        for nid in sorted(str(n) for n in members):
+            h.update(nid.encode("utf-8", "replace"))
+            h.update(b"\x00")
+        sigs[cid] = h.hexdigest()[:16]
+    return sigs
+
+
 def cluster(
     G: nx.Graph,
     resolution: float = 1.0,

{graphifyy-0.9.4 → graphifyy-0.9.6}/graphify/detect.py

@@ -27,7 +27,7 @@ class FileType(str, Enum):
 
 _MANIFEST_PATH = str(out_path("manifest.json"))
 
-CODE_EXTENSIONS = {'.py', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.ejs', '.ets', '.go', '.rs', '.java', '.groovy', '.gradle', '.cpp', '.cc', '.cxx', '.c', '.h', '.hpp', '.cu', '.cuh', '.metal', '.rb', '.swift', '.kt', '.kts', '.cs', '.scala', '.php', '.lua', '.luau', '.toc', '.zig', '.ps1', '.psm1', '.psd1', '.ex', '.exs', '.m', '.mm', '.jl', '.vue', '.svelte', '.astro', '.dart', '.v', '.sv', '.svh', '.sql', '.r', '.f', '.F', '.f90', '.F90', '.f95', '.F95', '.f03', '.F03', '.f08', '.F08', '.pas', '.pp', '.dpr', '.dpk', '.lpr', '.inc', '.dfm', '.lfm', '.lpk', '.sh', '.bash', '.json', '.tf', '.tfvars', '.hcl', '.dm', '.dme', '.dmi', '.dmm', '.dmf', '.sln', '.slnx', '.csproj', '.fsproj', '.vbproj', '.xaml', '.razor', '.cshtml', '.cls', '.trigger'}
+CODE_EXTENSIONS = {'.py', '.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.ejs', '.ets', '.go', '.rs', '.java', '.groovy', '.gradle', '.cpp', '.cc', '.cxx', '.c', '.h', '.hpp', '.cu', '.cuh', '.metal', '.rb', '.swift', '.kt', '.kts', '.cs', '.scala', '.php', '.lua', '.luau', '.toc', '.zig', '.ps1', '.psm1', '.psd1', '.ex', '.exs', '.m', '.mm', '.jl', '.vue', '.svelte', '.astro', '.dart', '.v', '.sv', '.svh', '.sql', '.r', '.f', '.F', '.f90', '.F90', '.f95', '.F95', '.f03', '.F03', '.f08', '.F08', '.pas', '.pp', '.dpr', '.dpk', '.lpr', '.inc', '.dfm', '.lfm', '.lpk', '.sh', '.bash', '.json', '.tf', '.tfvars', '.hcl', '.dm', '.dme', '.dmi', '.dmm', '.dmf', '.sln', '.slnx', '.csproj', '.fsproj', '.vbproj', '.xaml', '.razor', '.cshtml', '.cls', '.trigger'}
 DOC_EXTENSIONS = {'.md', '.mdx', '.qmd', '.txt', '.rst', '.html', '.yaml', '.yml'}
 PAPER_EXTENSIONS = {'.pdf'}
 IMAGE_EXTENSIONS = {'.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'}
@@ -991,14 +991,11 @@ def _could_contain_included_path(path: Path, root: Path, patterns: list[tuple[Pa
 
 
 def _auto_follow_symlinks(root: Path) -> bool:
-    """Auto-detect: ``True`` if ``root`` has any direct symlinked child.
+    """Return whether ``root`` has any direct symlinked child.
 
-    Allows "fake working dir" patterns (e.g. a folder full of symlinks pointing
-    at scattered source dirs across the user's machine) to work transparently
-    without the caller having to know to pass ``follow_symlinks=True``.
-
-    Override is always possible by passing an explicit ``follow_symlinks=True``
-    or ``follow_symlinks=False`` to :func:`detect` / :func:`detect_incremental`.
+    Kept for callers that import the private helper, but detection no longer
+    enables symlink following automatically. Following symlinks is now an
+    explicit opt-in, and out-of-root symlink targets are never indexed.
     """
     try:
         for p in root.iterdir():
@@ -1009,10 +1006,19 @@ def _auto_follow_symlinks(root: Path) -> bool:
     return False
 
 
+def _resolves_under_root(path: Path, root: Path) -> bool:
+    """True when ``path`` resolves to a target inside ``root``."""
+    try:
+        path.resolve().relative_to(root.resolve())
+    except (OSError, RuntimeError, ValueError):
+        return False
+    return True
+
+
 def detect(root: Path, *, follow_symlinks: bool | None = None, google_workspace: bool | None = None, extra_excludes: list[str] | None = None) -> dict:
     root = root.resolve()
     if follow_symlinks is None:
-        follow_symlinks = _auto_follow_symlinks(root)
+        follow_symlinks = False
     google_workspace = google_workspace_enabled() if google_workspace is None else google_workspace
     files: dict[FileType, list[str]] = {
         FileType.CODE: [],
@@ -1072,6 +1078,15 @@ def detect(root: Path, *, follow_symlinks: bool | None = None, google_workspace:
                     if not _is_noise_dir(d, dp)
                     and not _is_ignored(dp / d, root, ignore_patterns, _cache=ignore_cache)
                 ]
+                if follow_symlinks:
+                    safe_dirs: list[str] = []
+                    for d in dirnames:
+                        child = dp / d
+                        if child.is_symlink() and not _resolves_under_root(child, root):
+                            skipped_sensitive.append(str(child) + " [symlink target outside scan root]")
+                            continue
+                        safe_dirs.append(d)
+                    dirnames[:] = safe_dirs
             for fname in filenames:
                 if fname in _SKIP_FILES:
                     continue
@@ -1093,6 +1108,9 @@ def detect(root: Path, *, follow_symlinks: bool | None = None, google_workspace:
                 continue
         if not in_memory and _is_ignored(p, root, ignore_patterns, _cache=ignore_cache):
             continue
+        if not _resolves_under_root(p, root):
+            skipped_sensitive.append(str(p) + " [symlink target outside scan root]")
+            continue
         if _is_sensitive(p):
             skipped_sensitive.append(str(p))
             continue
@@ -1363,11 +1381,10 @@ def detect_incremental(
     Backwards compatible with legacy manifests storing plain float mtime values
     or {mtime, hash} dicts (treated as ast_hash only; semantic_hash = miss).
 
-    The ``follow_symlinks`` flag is forwarded to :func:`detect` so corpora that
-    rely on symlinked sub-trees (e.g. a ``state_of_truth/`` symlink pointing to a
-    directory outside the scan root) are scanned consistently between full and
-    incremental runs. ``None`` (default) means auto-detect: ``True`` when ``root``
-    contains at least one direct symlinked child, ``False`` otherwise.
+    The ``follow_symlinks`` flag is forwarded to :func:`detect` so in-root
+    symlinked sub-trees are scanned consistently between full and incremental
+    runs. ``None`` (default) does not follow symlinked directories; callers must
+    opt in explicitly, and resolved targets outside the scan root are skipped.
     """
     full = detect(root, follow_symlinks=follow_symlinks, google_workspace=google_workspace, extra_excludes=extra_excludes)
     # Pass ``root`` so a manifest written with relative keys (post-#777) is

{graphifyy-0.9.4 → graphifyy-0.9.6}/graphify/export.py

@@ -1278,7 +1278,10 @@ def to_canvas(
     group_sizes: dict[int, tuple[int, int]] = {}
     group_cols: dict[int, int] = {}
     for cid in sorted_cids:
-        members = communities[cid]
+        # Skip dangling community members with no backing node / filename, so box
+        # sizing matches the cards actually laid out and `G.nodes[m]` never
+        # KeyErrors below — mirrors the to_obsidian guard (#1236).
+        members = [m for m in communities[cid] if m in G and m in node_filenames]
         n = len(members)
         inner_cols = max(1, math.ceil(math.sqrt(n)))
         w = max(600, 220 * inner_cols)
@@ -1351,6 +1354,9 @@ def to_canvas(
         # Node cards inside the group - laid out in the same ceil(sqrt(n))-column
         # grid the box was sized for (group_cols[cid]), so cards fill the box.
         inner_cols = group_cols[cid]
+        # Same dangling-member guard as the sizing loop and to_obsidian (#1236):
+        # a community id absent from G / node_filenames would KeyError the sort.
+        members = [m for m in members if m in G and m in node_filenames]
         sorted_members = sorted(members, key=lambda n: G.nodes[n].get("label", n))
         for m_idx, node_id in enumerate(sorted_members):
             col = m_idx % inner_cols