cjm-capability-graph-sqlite 0.0.26__tar.gz → 0.0.28__tar.gz

{cjm_capability_graph_sqlite-0.0.26/cjm_capability_graph_sqlite.egg-info → cjm_capability_graph_sqlite-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-capability-graph-sqlite
-Version: 0.0.26
+Version: 0.0.28
 Summary: A local, file-backed context-graph storage capability for the cjm-substrate runtime that implements graph storage, traversal, and querying using SQLite.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0

cjm_capability_graph_sqlite-0.0.28/cjm_capability_graph_sqlite/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.28"

{cjm_capability_graph_sqlite-0.0.26 → cjm_capability_graph_sqlite-0.0.28}/cjm_capability_graph_sqlite/capability.py

@@ -82,6 +82,12 @@ class SQLiteGraphCapability(ToolCapability):
 
     config_class = SQLiteGraphCapabilityConfig
 
+    # Substrate observability class (DEC 8bf656c0 as manifest DATA, finding 0d886ffe B):
+    # graph-storage ops are compute-light, re-derivable work — routine per-op journal
+    # rows and worker-lifecycle rows are noise (they filled 97% of journal.db); failures
+    # still journal. `cjm-ctl regenerate-manifest` records this on the manifest.
+    observability_class = "ambient"
+
     def __init__(self):
         self.logger = logging.getLogger(f"{__name__}.{type(self).__name__}")
         self.config: SQLiteGraphCapabilityConfig = None
@@ -291,17 +297,23 @@ class SQLiteGraphCapability(ToolCapability):
         self,
         nodes: List[GraphNode]  # Nodes to create
     ) -> List[str]:  # Created node IDs
-        """Bulk create nodes."""
+        """Bulk create nodes.
+
+        A node arriving with created_at/updated_at already set keeps them —
+        journal REPLAY restores temporal provenance this way (finding 0d50b921:
+        stamping now() here clamped every rebuilt node to rebuild time)."""
         ids = []
         now = time.time()
         with self._connect() as con:
             for n in nodes:
                 sources_json = json.dumps([s.to_dict() for s in n.sources])
                 props_json = json.dumps(n.properties)
+                created = n.created_at if n.created_at is not None else now
+                updated = n.updated_at if n.updated_at is not None else created
                 try:
                     con.execute(
                         "INSERT INTO nodes (id, label, properties, sources, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
-                        (n.id, n.label, props_json, sources_json, now, now)
+                        (n.id, n.label, props_json, sources_json, created, updated)
                     )
                     ids.append(n.id)
                 except sqlite3.IntegrityError:
@@ -312,21 +324,40 @@ class SQLiteGraphCapability(ToolCapability):
         self,
         edges: List[GraphEdge]  # Edges to create
     ) -> List[str]:  # Created edge IDs
-        """Bulk create edges."""
+        """Bulk create edges.
+
+        Carried created_at/updated_at are honored like add_nodes (0d50b921).
+
+        Missing-endpoint edges (FOREIGN KEY failures) are AGGREGATED into one warning
+        per call — count + a bounded sample — never one line per edge: a rebuild replays
+        every journaled edge whose endpoint is absent, and per-edge logging flooded
+        diagnostics.db to 1.5M rows / 633 MB (finding 0d886ffe). The skipped count is
+        recoverable by the caller as `len(edges) - len(ids)`."""
         ids = []
         now = time.time()
+        missing: List[Tuple[str, str, str]] = []  # (source_id, target_id, relation_type) of FK-skipped edges
         with self._connect() as con:
             con.execute("PRAGMA foreign_keys = ON;")
             for e in edges:
                 props_json = json.dumps(e.properties)
+                created = e.created_at if e.created_at is not None else now
+                updated = e.updated_at if e.updated_at is not None else created
                 try:
                     con.execute(
                         "INSERT INTO edges (id, source_id, target_id, relation_type, properties, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
-                        (e.id, e.source_id, e.target_id, e.relation_type, props_json, now, now)
+                        (e.id, e.source_id, e.target_id, e.relation_type, props_json, created, updated)
                     )
                     ids.append(e.id)
                 except sqlite3.IntegrityError as err:
-                    self.logger.warning(f"Edge creation error (likely missing node): {err}")
+                    if "FOREIGN KEY" in str(err):
+                        missing.append((e.source_id, e.target_id, e.relation_type))
+                    else:
+                        self.logger.warning(f"Edge creation error ({e.id}): {err}")
+        if missing:
+            sample = "; ".join(f"{s[:8]}->{t[:8]} {r}" for s, t, r in missing[:3])
+            self.logger.warning(
+                f"add_edges: {len(missing)} of {len(edges)} edge(s) skipped — endpoint node missing "
+                f"(FOREIGN KEY); sample: {sample}")
         return ids
 
     # -------------------------------------------------------------------------
@@ -490,7 +521,14 @@ class SQLiteGraphCapability(ToolCapability):
         node_id: str,  # UUID of node to update
         properties: Dict[str, Any]  # Properties to merge/update
     ) -> bool:  # True if successful
-        """Partial update of node properties."""
+        """Partial update of node properties.
+
+        A reserved `updated_at` key in `properties` sets the COLUMN instead of
+        now() and never lands in the JSON blob — journal REPLAY restores a STATE
+        op's true time this way (0d50b921 residual: later-STATE nodes clamped
+        to rebuild time)."""
+        properties = dict(properties)
+        stamp = properties.pop("updated_at", None)
         with self._connect() as con:
             # Fetch existing to merge
             cur = con.execute("SELECT properties FROM nodes WHERE id = ?", (node_id,))
@@ -503,7 +541,7 @@ class SQLiteGraphCapability(ToolCapability):
 
             con.execute(
                 "UPDATE nodes SET properties = ?, updated_at = ? WHERE id = ?",
-                (json.dumps(existing), time.time(), node_id)
+                (json.dumps(existing), stamp if stamp is not None else time.time(), node_id)
             )
             return True
 

{cjm_capability_graph_sqlite-0.0.26 → cjm_capability_graph_sqlite-0.0.28}/cjm_capability_graph_sqlite/query_translation.py

@@ -22,9 +22,10 @@ Translation rules:
   does Python-side locator equality; a recurring need here is promotion
   evidence).
 - **Modes**: `count` > `project` > full (mirrors the result DTO contract).
-  Projected node rows always carry `id` (+ `label` projectable structurally;
-  `sources` projectable as parsed ref dicts); edge rows always carry
-  `id`/`source_id`/`target_id` (+ `relation_type` projectable)."""
+  Projected node rows always carry `id` (+ `label`/`created_at`/`updated_at`
+  projectable structurally — the storage stamps, never shadowed by a
+  same-named property; `sources` projectable as parsed ref dicts); edge rows
+  always carry `id`/`source_id`/`target_id` (+ `relation_type` projectable)."""
 
 import json
 import re
@@ -230,6 +231,9 @@ def translate_node_query(
             if name == "label":
                 select_parts.append("n.label")
                 keys.append("label")
+            elif name in ("created_at", "updated_at"):
+                select_parts.append("n." + name)   # storage stamp, not a property
+                keys.append(name)
             elif name == "sources":
                 select_parts.append("n.sources")
                 keys.append("sources")

{cjm_capability_graph_sqlite-0.0.26 → cjm_capability_graph_sqlite-0.0.28/cjm_capability_graph_sqlite.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cjm-capability-graph-sqlite
-Version: 0.0.26
+Version: 0.0.28
 Summary: A local, file-backed context-graph storage capability for the cjm-substrate runtime that implements graph storage, traversal, and querying using SQLite.
 Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
 License: Apache-2.0

{cjm_capability_graph_sqlite-0.0.26 → cjm_capability_graph_sqlite-0.0.28}/tests/test_capability.py

@@ -177,3 +177,47 @@ def test_typed_surface_smoke(cap):
     ctx = cap.export_graph(NodeQuery(label="Segment",
                                      related=RelationPredicate("PART_OF", node_id=doc)))
     assert len(ctx.nodes) == 3 and len(ctx.edges) == 2  # NEXT only (PART_OF targets the doc)
+
+
+def test_update_node_reserved_updated_at_sets_column(cap):
+    # 0d50b921 residual: a reserved `updated_at` key in the update payload sets
+    # the COLUMN (journal replay restores a STATE op's true time) and never
+    # lands in the JSON properties blob; without it, now()-stamping stands.
+    import json
+
+    nid = str(uuid.uuid4())
+    cap.add_nodes([GraphNode(id=nid, label="Person", properties={"name": "Ada"})])
+    assert cap.update_node(nid, {"role": "host", "updated_at": 1234.5})
+    con = sqlite3.connect(cap._db_path)
+    row = con.execute("SELECT properties, updated_at FROM nodes WHERE id = ?",
+                      (nid,)).fetchone()
+    con.close()
+    props = json.loads(row[0])
+    assert props["role"] == "host" and "updated_at" not in props
+    assert row[1] == 1234.5
+    # Without the reserved key the column re-stamps to now().
+    assert cap.update_node(nid, {"role": "guest"})
+    con = sqlite3.connect(cap._db_path)
+    row2 = con.execute("SELECT updated_at FROM nodes WHERE id = ?", (nid,)).fetchone()
+    con.close()
+    assert row2[0] > 1234.5
+
+
+def test_add_edges_aggregates_missing_endpoint_warnings(cap, caplog):
+    """Finding 0d886ffe: FK-skipped edges log ONE warning per call (count + sample),
+    never one line per edge — per-edge logging flooded diagnostics.db during rebuilds."""
+    import logging
+    from cjm_context_graph_primitives.graph import GraphEdge, GraphNode
+    cap.add_nodes([GraphNode(id="n-live", label="T", properties={}, sources=[])])
+    edges = [GraphEdge(id=f"e{i}", source_id="n-live", target_id=f"n-missing-{i}",
+                       relation_type="REL", properties={}) for i in range(25)]
+    edges.append(GraphEdge(id="e-ok", source_id="n-live", target_id="n-live",
+                           relation_type="SELF", properties={}))
+    with caplog.at_level(logging.WARNING):
+        ids = cap.add_edges(edges)
+    assert ids == ["e-ok"]  # skipped count recoverable as len(edges) - len(ids)
+    fk_lines = [r for r in caplog.records if "endpoint node missing" in r.getMessage()]
+    assert len(fk_lines) == 1
+    msg = fk_lines[0].getMessage()
+    assert "25 of 26" in msg and "sample:" in msg
+    assert not any("Edge creation error (likely missing node)" in r.getMessage() for r in caplog.records)

{cjm_capability_graph_sqlite-0.0.26 → cjm_capability_graph_sqlite-0.0.28}/tests/test_query_translation.py

@@ -85,6 +85,18 @@ def test_spine_read_ordered_projection(con):
     assert json.loads(rows[1]["sources"])[0]["content_hash"] == "sha256:ab"
 
 
+def test_structural_timestamp_projection(con):
+    # created_at/updated_at project from the storage COLUMNS (the stamps),
+    # not json_extract over properties — no Segment carries them as props.
+    rows = run(con, NodeQuery(label="Segment",
+                              related=RelationPredicate("PART_OF", node_id="doc-1"),
+                              order_by=OrderBy(prop="index"),
+                              project=["index", "created_at", "updated_at"]))
+    assert [r["created_at"] for r in rows] == [1.0, 1.0, 1.0, 1.0]
+    assert rows[0]["updated_at"] == 1.0
+    assert rows[0]["id"] == "s0"
+
+
 def test_empty_filter_or_case_two_counts(con):
     empty_eq = run(con, NodeQuery(label="Segment", where=[PropertyPredicate("text", "eq", "")],
                                   related=RelationPredicate("PART_OF", node_id="doc-1"), count=True))

cjm_capability_graph_sqlite-0.0.26/cjm_capability_graph_sqlite/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.0.26"