graphify-vault 0.5.8a0__tar.gz → 0.6.0__tar.gz

{graphify_vault-0.5.8a0/graphify_vault.egg-info → graphify_vault-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify_vault
-Version: 0.5.8a0
+Version: 0.6.0
 Summary: Fork of github.com/safishamsi/graphify with GRAPHIFY_WORKSPACE path resolution for distributed graph artifacts, same-label node merging, incremental build fixes, and local knowledge vault capabilities
 License: MIT License
         

{graphify_vault-0.5.8a0 → graphify_vault-0.6.0}/graphify/__main__.py

@@ -1246,6 +1246,7 @@ def _apply_enhance_result(gp: Path, candidates_path: Path, enhance_data: dict) -
 
     _raw_out["nodes"] = list(node_map.values())
     _raw_out["edges"] = list(edge_set.values())
+    _raw_out.pop("links", None)  # remove stale "links" key to avoid duplication
 
     gp.write_text(json.dumps(_raw_out, indent=2, ensure_ascii=False), encoding="utf-8")
     print(f"Graph updated: {len(_raw_out['nodes'])} nodes, {len(_raw_out['edges'])} edges → {gp}")

{graphify_vault-0.5.8a0 → graphify_vault-0.6.0}/graphify/build_cmd.py

@@ -15,6 +15,7 @@ resolves to graphify_vault — no sys.path hacks needed.
 from __future__ import annotations
 
 import json
+import os
 import re
 import sys
 import zipfile
@@ -569,6 +570,9 @@ def run_build(args: list[str] | None = None) -> None:
         "--depth", type=int, default=2, choices=[1, 2, 3], help="Semantic extraction depth (default: 2)"
     )
     parser.add_argument("--no-dedup", action="store_true", help="Skip entity deduplication step")
+    parser.add_argument(
+        "--no-simplify", action="store_true", help="Skip graph simplification (prune empty/low-info nodes)"
+    )
     parser.add_argument("--llm", action="store_true", help="Enable LLM enhancement for Topic layer after build")
     parser.add_argument(
         "--provider",
@@ -580,8 +584,8 @@ def run_build(args: list[str] | None = None) -> None:
     parser.add_argument("--model", default=None, help="LLM model name (overrides env var)")
     opts = parser.parse_args(args)
 
-    # --workspace takes precedence over positional path; default to "."
-    workspace_arg = opts.workspace or opts.path or "."
+    # --workspace takes precedence over positional path; fall back to GRAPHIFY_WORKSPACE env var, then "."
+    workspace_arg = opts.workspace or opts.path or os.environ.get("GRAPHIFY_WORKSPACE", ".")
 
     from graphify.analyze import god_nodes, suggest_questions, surprising_connections
     from graphify.build import build_from_json
@@ -609,15 +613,19 @@ def run_build(args: list[str] | None = None) -> None:
     print(f"Extract produced {len(result['nodes'])} nodes / {len(result['edges'])} edges")
 
     G = build_from_json(result)
-    communities = cluster(G)
 
     if not opts.no_dedup:
         from graphify.dedup import deduplicate_graph
 
         pre_count = G.number_of_nodes()
         G = deduplicate_graph(G)
-        if G.number_of_nodes() < pre_count:
-            communities = cluster(G)
+
+    if not opts.no_simplify:
+        from graphify.simplify import simplify_graph
+
+        simplify_graph(G)
+
+    communities = cluster(G)
 
     cohesion = score_all(G, communities)
     gods = god_nodes(G)
@@ -841,15 +849,19 @@ def run_build(args: list[str] | None = None) -> None:
     print(f"After merge: {len(merged_nodes)} nodes, {len(merged_edges)} edges")
 
     G = build_from_json(merged_result)
-    communities = cluster(G)
 
     if not opts.no_dedup:
         from graphify.dedup import deduplicate_graph
 
         pre_count = G.number_of_nodes()
         G = deduplicate_graph(G)
-        if G.number_of_nodes() < pre_count:
-            communities = cluster(G)
+
+    if not opts.no_simplify:
+        from graphify.simplify import simplify_graph
+
+        simplify_graph(G)
+
+    communities = cluster(G)
 
     cohesion = score_all(G, communities)
     gods = god_nodes(G)

{graphify_vault-0.5.8a0 → graphify_vault-0.6.0}/graphify/query_log.py

@@ -43,8 +43,15 @@ def write_entry(
     workspace: str,
     seed_ids: list[str] | None = None,
     result_node_ids: list[str] | None = None,
+    *,
+    auto_rotate: bool = True,
 ) -> None:
-    """Append one JSONL line to today's log file."""
+    """Append one JSONL line to today's log file.
+
+    auto_rotate: if True (default), spawn a background thread to compress
+    old logs and clean up.  Set to False when the caller manages rotation
+    ordering (e.g. MCP server runs feedback analysis before rotation).
+    """
     if not is_enabled():
         return
     log_dir = _LOG_DIR
@@ -54,7 +61,8 @@ def write_entry(
         print(f"[query_log] cannot create log dir {log_dir}: {e}", file=sys.stderr)
         return
 
-    threading.Thread(target=_rotate_and_cleanup, args=(log_dir,), daemon=True).start()
+    if auto_rotate:
+        threading.Thread(target=_rotate_and_cleanup, args=(log_dir,), daemon=True).start()
 
     today_str = datetime.now().strftime("%Y-%m-%d")
     log_file = log_dir / f"query_{today_str}.jsonl"
@@ -83,12 +91,27 @@ def write_entry(
 def _rotate_and_cleanup(log_dir: Path) -> None:
     """Compress old jsonl files to zip and delete zips older than 7 days.
 
-    Keeps yesterday's log uncompressed so feedback analysis can read it.
+    Keeps today's and yesterday's logs uncompressed.  For older logs,
+    checks the feedback marker before zipping — if GRAPHIFY_WORKSPACE
+    is set and the marker directory exists but the marker file is missing,
+    the log is kept uncompressed for feedback analysis.  If the workspace
+    is unset or the graphify-out directory doesn't exist, zips normally
+    to avoid unbounded disk growth.
     """
     today = datetime.now()
     today_str = today.strftime("%Y-%m-%d")
     yesterday_str = (today - timedelta(days=1)).strftime("%Y-%m-%d")
 
+    # Resolve feedback marker directory (if available)
+    import os
+
+    marker_dir = None
+    ws = os.environ.get("GRAPHIFY_WORKSPACE", "")
+    if ws:
+        candidate = Path(ws) / "graphify-out"
+        if candidate.is_dir():
+            marker_dir = candidate
+
     # Compress old jsonl files (skip today and yesterday)
     for jsonl_file in list(log_dir.glob("query_*.jsonl")):
         # Extract date from filename: query_YYYY-MM-DD.jsonl
@@ -97,6 +120,12 @@ def _rotate_and_cleanup(log_dir: Path) -> None:
         if file_date_str in (today_str, yesterday_str):
             continue
 
+        # Don't zip if feedback analysis hasn't processed this log yet.
+        if marker_dir is not None:
+            marker = marker_dir / f".feedback_analyzed_{stem}"
+            if not marker.exists():
+                continue
+
         zip_path = log_dir / f"{jsonl_file.name}.zip"
         try:
             with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:

{graphify_vault-0.5.8a0 → graphify_vault-0.6.0}/graphify/serve.py

@@ -3166,11 +3166,10 @@ def _task_results_to_text(
     return "\n".join(lines)
 
 
-def _log_query(question: str, payload: dict) -> None:
+def _log_query(question: str, payload: dict, *, auto_rotate: bool = True) -> None:
     """Write query_log entry from _query_graph results. Works for both MCP and direct calls."""
     try:
         import os
-        import time as _time
 
         from graphify.query_log import write_entry
 
@@ -3185,6 +3184,7 @@ def _log_query(question: str, payload: dict) -> None:
             workspace=os.environ.get("GRAPHIFY_WORKSPACE", ""),
             seed_ids=seed_ids or None,
             result_node_ids=result_ids or None,
+            auto_rotate=auto_rotate,
         )
     except Exception:
         pass
@@ -3204,10 +3204,10 @@ def _query_graph(
     god_labels: set[str] | None = None,
     rerank: bool = True,
     feedback: dict[str, float] | None = None,
+    _auto_rotate_log: bool = True,
 ) -> dict[str, object]:
     # Clamp token_budget to safe range for direct callers bypassing MCP schema
-    if token_budget < 1 or token_budget > 100000:
-        token_budget = 2000
+    token_budget = max(1, min(token_budget, 100000))
     if feedback is None:
         feedback = G.graph.get("_feedback")
     if feedback is None:
@@ -3377,7 +3377,7 @@ def _query_graph(
         payload["text"] = _task_results_to_text(
             payload, token_budget=token_budget, traversal_mode=traversal_mode, depth=depth
         )
-        _log_query(question, payload)
+        _log_query(question, payload, auto_rotate=_auto_rotate_log)
         return payload
 
     scored = _score_nodes(G, terms)
@@ -3436,7 +3436,7 @@ def _query_graph(
         "results": results,
         "text": text if not json_output else text,
     }
-    _log_query(question, payload)
+    _log_query(question, payload, auto_rotate=_auto_rotate_log)
     return payload
 
 
@@ -3712,6 +3712,12 @@ def serve(graph_path: str = "graphify-out/graph.json", workspace: str | None = N
             types.Tool(
                 name="query_graph",
                 description="Search the knowledge graph using BFS or DFS. Returns relevant nodes and edges as text context.",
+                annotations=types.ToolAnnotations(
+                    readOnlyHint=True,
+                    destructiveHint=False,
+                    idempotentHint=True,
+                    openWorldHint=False,
+                ),
                 inputSchema={
                     "type": "object",
                     "properties": {
@@ -3762,11 +3768,23 @@ def serve(graph_path: str = "graphify-out/graph.json", workspace: str | None = N
             types.Tool(
                 name="graph_stats",
                 description="Return summary statistics: node count, edge count, communities, confidence breakdown.",
+                annotations=types.ToolAnnotations(
+                    readOnlyHint=True,
+                    destructiveHint=False,
+                    idempotentHint=True,
+                    openWorldHint=False,
+                ),
                 inputSchema={"type": "object", "properties": {}},
             ),
             types.Tool(
                 name="switch_workspace",
                 description="Switch to a different graphify-out workspace (e.g. different version). Hot-reloads the graph without restarting the MCP server.",
+                annotations=types.ToolAnnotations(
+                    readOnlyHint=False,
+                    destructiveHint=False,
+                    idempotentHint=True,
+                    openWorldHint=False,
+                ),
                 inputSchema={
                     "type": "object",
                     "properties": {
@@ -3793,8 +3811,7 @@ def serve(graph_path: str = "graphify-out/graph.json", workspace: str | None = N
             return f"Input validation error: depth={raw_depth} is out of range (1-6)"
         depth = raw_depth
         budget = int(arguments.get("token_budget", 2000))
-        if budget < 1 or budget > 100000:
-            budget = 2000
+        budget = max(1, min(budget, 100000))
         max_degree = int(arguments.get("max_degree", 0))
         if max_degree < 0:
             max_degree = 0
@@ -3829,18 +3846,48 @@ def serve(graph_path: str = "graphify-out/graph.json", workspace: str | None = N
                 header = f"Traversal: {mode.upper()} depth={depth} max_degree={max_degree or '∞'} | Start: {start_nodes} | {len(results)} ranked matches\n\n"
                 result_text = header + str(payload.get("text", ""))
         try:
-            from graphify.feedback import _maybe_run_daily_analysis
-            from graphify.query_log import _LOG_DIR
+            from graphify.query_log import _LOG_DIR, _rotate_and_cleanup
 
             _fb_dir = Path(_state["G"].graph.get("_graph_dir", ""))
-            if _fb_dir.is_dir():
-
-                def _refresh_feedback():
-                    from graphify.feedback import load_feedback
-
-                    _state["feedback"] = load_feedback(_fb_dir)
 
-                _maybe_run_daily_analysis(_fb_dir, _LOG_DIR, on_complete=_refresh_feedback)
+            def _post_query_maintenance():
+                """Run feedback analysis BEFORE log rotation in one thread.
+
+                This guarantees analyze_daily_log can read yesterday's
+                uncompressed .jsonl before _rotate_and_cleanup zips it.
+                """
+                try:
+                    if _fb_dir.is_dir():
+                        from graphify.feedback import analyze_daily_log, load_feedback
+
+                        def _refresh():
+                            _state["feedback"] = load_feedback(_fb_dir)
+
+                        from datetime import datetime, timedelta
+
+                        yesterday_str = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")
+                        log_path = _LOG_DIR / f"query_{yesterday_str}.jsonl"
+                        marker = _fb_dir / f".feedback_analyzed_query_{yesterday_str}"
+                        if not marker.exists():
+                            n = analyze_daily_log(log_path, _fb_dir)
+                            if n > 0:
+                                print(
+                                    f"[feedback] analyzed {yesterday_str} log, updated {n} node(s)",
+                                    file=sys.stderr,
+                                )
+                                _refresh()
+                except Exception as exc:
+                    print(f"[feedback] maintenance error: {exc}", file=sys.stderr)
+
+                # Now safe to rotate (zip old logs)
+                try:
+                    _rotate_and_cleanup(_LOG_DIR)
+                except Exception:
+                    pass
+
+            import threading
+
+            threading.Thread(target=_post_query_maintenance, daemon=True).start()
         except Exception:
             pass
         return result_text

graphify_vault-0.6.0/graphify/simplify.py

@@ -0,0 +1,289 @@
+# simplify.py — prune low-information-density nodes from a knowledge graph
+#
+# Designed to run in the build pipeline between dedup and cluster:
+#   extract → assemble → dedup → **simplify** → cluster → export
+#
+# All pruning decisions are based on structural statistics (raws length,
+# degree, line range), never on hardcoded labels or project-specific names.
+from __future__ import annotations
+
+import sys
+
+import networkx as nx
+
+# ── Thresholds (tunable, based on empirical analysis) ────────────────────
+
+_MIN_CONTENT_CHARS = 20  # raws join < this → "no content"
+_LEAF_MAX_DEGREE = 5  # empty + degree ≤ this → prunable leaf
+_HUB_MIN_DEGREE = 6  # empty + degree ≥ this → hub candidate
+_MAX_BRIDGE_NEIGHBORS = 50  # limit bridging fan-out to avoid edge explosion
+_HEADING_MIN_CHARS = 20  # single-line node with raws < this → heading-only
+
+
+def _has_content(ndata: dict) -> bool:
+    """Return True if a node carries meaningful textual content."""
+    raws = ndata.get("raws", [])
+    raws_text = " ".join(raws) if isinstance(raws, list) else str(raws or "")
+    return len(raws_text.strip()) >= _MIN_CONTENT_CHARS
+
+
+def _neighbor_count(G: nx.Graph, nid: str) -> int:
+    """Return the number of unique neighbors (not counting parallel edges)."""
+    return len(set(G.neighbors(nid)))
+
+
+def _is_single_line_heading(ndata: dict) -> bool:
+    """Return True if a node is a single-line heading with no real content."""
+    sl = ndata.get("start_line")
+    el = ndata.get("end_line")
+    if sl is None or el is None or sl != el:
+        return False
+    raws = ndata.get("raws", [])
+    raws_text = " ".join(raws) if isinstance(raws, list) else str(raws or "")
+    return len(raws_text.strip()) < _HEADING_MIN_CHARS
+
+
+# ── Strategy 1: prune low-degree empty nodes ─────────────────────────────
+
+
+def prune_empty_leaves(G: nx.Graph, *, max_degree: int = _LEAF_MAX_DEGREE) -> int:
+    """Remove nodes with no content and degree ≤ max_degree.
+
+    These are leaf or near-leaf nodes that contribute nothing to retrieval.
+    Returns the number of nodes removed.
+    """
+    to_remove = [
+        nid for nid in list(G.nodes()) if not _has_content(G.nodes[nid]) and _neighbor_count(G, nid) <= max_degree
+    ]
+    G.remove_nodes_from(to_remove)
+    return len(to_remove)
+
+
+# ── Strategy 2: collapse high-degree empty hubs ──────────────────────────
+
+
+def collapse_empty_hubs(
+    G: nx.Graph,
+    *,
+    min_degree: int = _HUB_MIN_DEGREE,
+    max_bridge: int = _MAX_BRIDGE_NEIGHBORS,
+    bridge_degree_cap: int = 30,
+) -> int:
+    """Remove empty hub nodes, optionally bridging their neighbors.
+
+    - Hubs with degree ≤ bridge_degree_cap: bridge top-max_bridge neighbors
+      to preserve local connectivity, then remove the hub.
+    - Hubs with degree > bridge_degree_cap: remove without bridging.  These
+      are file-scope container nodes (e.g. ``(top)``) whose neighbors are
+      already connected through the content graph — bridging them would
+      create O(N²) new edges for no retrieval benefit.
+
+    Returns the number of hub nodes removed.
+    """
+    removed = 0
+    # Snapshot node list — graph mutates during iteration
+    candidates = [
+        nid for nid in list(G.nodes()) if not _has_content(G.nodes[nid]) and _neighbor_count(G, nid) >= min_degree
+    ]
+
+    for nid in candidates:
+        if nid not in G:
+            continue  # already removed by a prior collapse
+
+        ncnt = _neighbor_count(G, nid)
+        neighbors = list(set(G.neighbors(nid)))
+        if not neighbors:
+            G.remove_node(nid)
+            removed += 1
+            continue
+
+        # High-degree super-hubs: remove without bridging
+        if ncnt > bridge_degree_cap:
+            G.remove_node(nid)
+            removed += 1
+            continue
+
+        # Moderate hubs: bridge top neighbors then remove
+        def _edge_weight(nbr: str) -> float:
+            if not G.has_edge(nid, nbr):
+                return 1.0
+            edge_bundle = G[nid][nbr]
+            if isinstance(edge_bundle, dict) and "weight" in edge_bundle:
+                return float(edge_bundle.get("weight", 1.0))
+            try:
+                return max(
+                    (float(d.get("weight", 1.0)) for d in edge_bundle.values() if isinstance(d, dict)),
+                    default=1.0,
+                )
+            except (TypeError, AttributeError):
+                return 1.0
+
+        if len(neighbors) > max_bridge:
+            neighbors = sorted(neighbors, key=_edge_weight, reverse=True)[:max_bridge]
+
+        hub_label = G.nodes[nid].get("label", "")
+        for i, u in enumerate(neighbors):
+            for v in neighbors[i + 1 :]:
+                if not G.has_edge(u, v):
+                    G.add_edge(
+                        u,
+                        v,
+                        relation="implicit",
+                        context="simplified",
+                        confidence="INFERRED",
+                        confidence_score=0.5,
+                        weight=0.5,
+                        _simplified_from=hub_label,
+                    )
+
+        G.remove_node(nid)
+        removed += 1
+
+    return removed
+
+
+# ── Strategy 3: merge single-line headings into children ─────────────────
+
+
+def merge_single_line_headings(G: nx.Graph) -> int:
+    """Merge single-line heading nodes into their first content-bearing neighbor.
+
+    The heading's label is preserved as a ``heading_context`` attribute on
+    the target node so retrieval signals are not lost.
+
+    Returns the number of heading nodes merged.
+    """
+    merged = 0
+    candidates = [nid for nid in list(G.nodes()) if _is_single_line_heading(G.nodes[nid])]
+
+    for nid in candidates:
+        if nid not in G:
+            continue
+
+        ndata = G.nodes[nid]
+        label = ndata.get("label", "")
+        neighbors = list(G.neighbors(nid))
+
+        # Find the best merge target: prefer a neighbor with content
+        target = None
+        for nbr in neighbors:
+            if _has_content(G.nodes[nbr]):
+                target = nbr
+                break
+
+        if target is None:
+            # No content-bearing neighbor — skip, don't orphan edges
+            continue
+
+        # Transfer heading label as context
+        existing_ctx = G.nodes[target].get("heading_context", "")
+        if existing_ctx:
+            G.nodes[target]["heading_context"] = f"{existing_ctx} > {label}"
+        else:
+            G.nodes[target]["heading_context"] = label
+
+        # Re-wire: connect all other neighbors of the heading to the target
+        is_multi = isinstance(G, (nx.MultiGraph, nx.MultiDiGraph))
+        for nbr in neighbors:
+            if nbr == target:
+                continue
+            if G.has_edge(nid, nbr):
+                edge_bundle = G[nid][nbr]
+                if is_multi:
+                    # MultiGraph: copy ALL parallel edges to preserve relations
+                    for _key, ed in edge_bundle.items():
+                        if isinstance(ed, dict):
+                            G.add_edge(target, nbr, **dict(ed))
+                else:
+                    # Simple Graph: only add if no existing edge
+                    if not G.has_edge(target, nbr):
+                        G.add_edge(target, nbr, **dict(edge_bundle))
+
+        G.remove_node(nid)
+        merged += 1
+
+    return merged
+
+
+# ── Strategy 4: merge duplicate edges ────────────────────────────────────
+
+
+def merge_duplicate_edges(G: nx.Graph) -> int:
+    """Merge parallel edges with the same (u, v, relation) in a MultiGraph.
+
+    Keeps the edge with the highest weight; discards the rest.
+    For non-MultiGraph instances, this is a no-op.
+
+    Returns the number of redundant edges removed.
+    """
+    if not isinstance(G, (nx.MultiGraph, nx.MultiDiGraph)):
+        return 0
+
+    removed = 0
+    # Snapshot: collect all node pairs that have edges
+    for u, v in list(set(G.edges())):
+        edge_bundle = G[u][v]
+        if len(edge_bundle) <= 1:
+            continue
+
+        # Group parallel edges by relation
+        by_relation: dict[str, list[tuple]] = {}
+        for key, edata in edge_bundle.items():
+            rel = edata.get("relation", "")
+            by_relation.setdefault(rel, []).append((key, edata))
+
+        for rel, group in by_relation.items():
+            if len(group) <= 1:
+                continue
+            # Keep the edge with the highest weight
+            group.sort(key=lambda x: float(x[1].get("weight", 1.0)), reverse=True)
+            for key, _ in group[1:]:
+                G.remove_edge(u, v, key=key)
+                removed += 1
+
+    return removed
+
+
+# ── Top-level entry point ────────────────────────────────────────────────
+
+
+def simplify_graph(G: nx.Graph, *, verbose: bool = True) -> dict[str, int]:
+    """Run all simplification strategies on the graph in-place.
+
+    Returns a dict of statistics: {strategy_name: count_affected}.
+    """
+    pre_nodes = G.number_of_nodes()
+    pre_edges = G.number_of_edges()
+
+    stats: dict[str, int] = {}
+
+    # Order matters: prune leaves first (cheap), then collapse hubs
+    # (may create new leaves but they have bridged edges so won't be
+    # re-pruned), then merge headings (operates on remaining structure).
+    stats["pruned_leaves"] = prune_empty_leaves(G)
+    stats["collapsed_hubs"] = collapse_empty_hubs(G)
+    stats["merged_headings"] = merge_single_line_headings(G)
+    stats["merged_edges"] = merge_duplicate_edges(G)
+
+    post_nodes = G.number_of_nodes()
+    post_edges = G.number_of_edges()
+    stats["nodes_before"] = pre_nodes
+    stats["nodes_after"] = post_nodes
+    stats["edges_before"] = pre_edges
+    stats["edges_after"] = post_edges
+
+    if verbose:
+        pct = (1 - post_nodes / pre_nodes) * 100 if pre_nodes else 0
+        print(
+            f"Simplify: {pre_nodes} → {post_nodes} nodes ({pct:.1f}% reduction), {pre_edges} → {post_edges} edges",
+            file=sys.stderr,
+        )
+        print(
+            f"  pruned_leaves={stats['pruned_leaves']}, "
+            f"collapsed_hubs={stats['collapsed_hubs']}, "
+            f"merged_headings={stats['merged_headings']}, "
+            f"merged_edges={stats['merged_edges']}",
+            file=sys.stderr,
+        )
+
+    return stats

{graphify_vault-0.5.8a0 → graphify_vault-0.6.0/graphify_vault.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify_vault
-Version: 0.5.8a0
+Version: 0.6.0
 Summary: Fork of github.com/safishamsi/graphify with GRAPHIFY_WORKSPACE path resolution for distributed graph artifacts, same-label node merging, incremental build fixes, and local knowledge vault capabilities
 License: MIT License
         

{graphify_vault-0.5.8a0 → graphify_vault-0.6.0}/graphify_vault.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ graphify/query_log.py
 graphify/report.py
 graphify/security.py
 graphify/serve.py
+graphify/simplify.py
 graphify/skill.md
 graphify/transcribe.py
 graphify/validate.py
@@ -89,6 +90,7 @@ tests/test_semantic_similarity.py
 tests/test_serve.py
 tests/test_serve_multigraph.py
 tests/test_serve_multigraph_load.py
+tests/test_simplify.py
 tests/test_sort_by.py
 tests/test_spatial_craft_build.py
 tests/test_spatialsdk_query_regression.py

{graphify_vault-0.5.8a0 → graphify_vault-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphify_vault"
-version = "0.5.8.alpha"
+version = "0.6.0"
 description = "Fork of github.com/safishamsi/graphify with GRAPHIFY_WORKSPACE path resolution for distributed graph artifacts, same-label node merging, incremental build fixes, and local knowledge vault capabilities"
 readme = "README.md"
 license = { file = "LICENSE" }