devin-graph 0.1.1__tar.gz → 0.1.2__tar.gz

{devin_graph-0.1.1/src/devin_graph.egg-info → devin_graph-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devin-graph
-Version: 0.1.1
+Version: 0.1.2
 Summary: Knowledge graph over Devin sessions — projects, files, tools and decisions as queryable nodes.
 Author: Icaro0310
 License: MIT
@@ -97,6 +97,10 @@ devin-graph query projects-graph           --graph graph.db --json
 
 # D3-friendly dump: {"meta", "nodes", "edges"}
 devin-graph export --format json --graph graph.db --out graph.json
+
+# diagnostics: edge-less nodes (report-only) and per-session blame
+devin-graph orphans                      --graph graph.db
+devin-graph blame-session <id-or-prefix> --graph graph.db
 ```
 
 Matching is forgiving (`src/app.py` finds `/repo/alpha/src/app.py`);
@@ -105,6 +109,15 @@ by two or more distinct projects, with the project and session lists —
 exportable as JSON like the other queries. The source DB is opened
 `mode=ro` and never written — tests assert its hash is unchanged.
 
+`orphans` lists nodes with no incident edges (id, kind, owner, a
+`prunable` flag marking the subset the next `build` would drop —
+shared, ownerless nodes; owned orphans persist with their owner). It is
+report-only and never deletes. `blame-session <id>` shows what a
+session produced and touched: its owned nodes and edges plus the
+resolved files, tools, projects and commits reachable through them,
+with the extraction-ledger timestamp. `<id>` accepts a unique prefix;
+a missing or ambiguous match exits 2 and lists candidates.
+
 ## Works with Devin alone (Devin-only mode)
 
 devin-graph builds `graph.db` locally from Devin's session stores — the whole

{devin_graph-0.1.1 → devin_graph-0.1.2}/README.md

@@ -80,6 +80,10 @@ devin-graph query projects-graph           --graph graph.db --json
 
 # D3-friendly dump: {"meta", "nodes", "edges"}
 devin-graph export --format json --graph graph.db --out graph.json
+
+# diagnostics: edge-less nodes (report-only) and per-session blame
+devin-graph orphans                      --graph graph.db
+devin-graph blame-session <id-or-prefix> --graph graph.db
 ```
 
 Matching is forgiving (`src/app.py` finds `/repo/alpha/src/app.py`);
@@ -88,6 +92,15 @@ by two or more distinct projects, with the project and session lists —
 exportable as JSON like the other queries. The source DB is opened
 `mode=ro` and never written — tests assert its hash is unchanged.
 
+`orphans` lists nodes with no incident edges (id, kind, owner, a
+`prunable` flag marking the subset the next `build` would drop —
+shared, ownerless nodes; owned orphans persist with their owner). It is
+report-only and never deletes. `blame-session <id>` shows what a
+session produced and touched: its owned nodes and edges plus the
+resolved files, tools, projects and commits reachable through them,
+with the extraction-ledger timestamp. `<id>` accepts a unique prefix;
+a missing or ambiguous match exits 2 and lists candidates.
+
 ## Works with Devin alone (Devin-only mode)
 
 devin-graph builds `graph.db` locally from Devin's session stores — the whole

{devin_graph-0.1.1 → devin_graph-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devin-graph"
-version = "0.1.1"
+version = "0.1.2"
 description = "Knowledge graph over Devin sessions — projects, files, tools and decisions as queryable nodes."
 readme = "README.md"
 license = { text = "MIT" }

devin_graph-0.1.2/src/devin_graph/__init__.py

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

{devin_graph-0.1.1 → devin_graph-0.1.2}/src/devin_graph/cli.py

@@ -13,6 +13,8 @@ from devin_internals.parsers import SessionsStore
 from devin_graph import __version__
 from devin_graph.paths import default_sessions_db, default_state_vscdb
 from devin_graph.query import (
+    blame_session,
+    orphaned_nodes,
     project_detail,
     projects_graph,
     sessions_for_file,
@@ -110,6 +112,24 @@ def build_parser() -> argparse.ArgumentParser:
     sq.add_argument("--json", action="store_true")
     sq.set_defaults(func=_cmd_query)
 
+    o = sub.add_parser(
+        "orphans", help="nodes with no incident edges — report-only, "
+        "never deletes (prunable flags what the next build would drop)")
+    _add_graph(o)
+    o.add_argument("--json", action="store_true")
+    o.set_defaults(func=_cmd_orphans)
+
+    bl = sub.add_parser(
+        "blame-session",
+        help="what a session produced/touched in the graph — owned "
+        "nodes and edges plus the files, tools, projects and commits "
+        "they reach")
+    bl.add_argument(
+        "session_id", help="session id or unique prefix")
+    _add_graph(bl)
+    bl.add_argument("--json", action="store_true")
+    bl.set_defaults(func=_cmd_blame)
+
     e = sub.add_parser("export", help="dump nodes+edges (D3-friendly)")
     e.add_argument("--format", choices=["json"], default="json")
     _add_graph(e)
@@ -226,6 +246,64 @@ def _print_query(what: str, data: dict) -> None:
             print(f"call: {t['id']} → {t['file']}")
 
 
+def _cmd_orphans(args: argparse.Namespace) -> int:
+    with _open_graph(args.graph) as gs:
+        data = orphaned_nodes(gs)
+    if args.json:
+        print(json.dumps(data, ensure_ascii=False, indent=2))
+        return 0
+    if not data["nodes"]:
+        print("no orphaned nodes")
+        return 0
+    for n in data["nodes"]:
+        label = n.get("name") or ""
+        keep = "" if n["prunable"] else " (owned — kept by prune)"
+        print(f"{n['id']}  {label}{keep}".rstrip())
+    print(f"{data['count']} orphan(s)")
+    return 0
+
+
+def _cmd_blame(args: argparse.Namespace) -> int:
+    with _open_graph(args.graph) as gs:
+        data = blame_session(gs, args.session_id)
+    if data["session"] is None:
+        cand = data.get("candidates") or []
+        hint = f" — candidates: {', '.join(cand[:10])}" if cand else ""
+        print(
+            f"devin-graph: no session matches {args.session_id!r}{hint}",
+            file=sys.stderr,
+        )
+        return 2
+    if args.json:
+        print(json.dumps(data, ensure_ascii=False, indent=2))
+        return 0
+    s = data["session"]
+    print(f"session: {data['session_id']}  {s.get('title') or 'Untitled'}")
+    if data["projects"]:
+        print("project: " + ", ".join(data["projects"]))
+    c = data["counts"]
+    print(
+        f"produced: {c['nodes']} node(s), {c['edges']} edge(s) · "
+        f"touched: {c['files']} file(s), {c['tools']} tool(s), "
+        f"{c['commits']} commit(s)"
+    )
+    if data["nodes_owned"]:
+        owned = [n for n in data["nodes_owned"] if n["kind"] == "tool_call"]
+        if owned:
+            print(f"tool calls ({len(owned)}):")
+            for n in owned:
+                print(f"  {n['key']}")
+    if data["files"]:
+        print(f"files ({len(data['files'])}):")
+        for f in data["files"]:
+            print(f"  {f}")
+    if data["tools"]:
+        print("tools: " + ", ".join(data["tools"]))
+    for cm in data["commits"]:
+        print(f"commit {cm['sha'][:7]} ({cm['relation']})")
+    return 0
+
+
 def _cmd_export(args: argparse.Namespace) -> int:
     with _open_graph(args.graph) as gs:
         data = gs.export()

{devin_graph-0.1.1 → devin_graph-0.1.2}/src/devin_graph/query.py

@@ -232,3 +232,103 @@ def shared_files(gs) -> dict:
             "sessions": sorted(sessions_of_file[file_key]),
         })
     return {"count": len(files), "files": files}
+
+
+def orphaned_nodes(gs) -> dict:
+    """Nodes with no incident edges — report-only, never deletes.
+
+    ``prunable`` marks the subset the builder's orphan prune would drop
+    on the next run (shared nodes — ``owner IS NULL`` — with no edges);
+    owned orphans (e.g. a session with no tool calls and no project)
+    carry provenance through their owner and persist until that owner
+    is re-extracted or removed.
+    """
+    endpoints = {e.src for e in gs.edges()} | {e.dst for e in gs.edges()}
+    nodes = [
+        {
+            "id": n.id,
+            "kind": n.kind,
+            "key": n.key,
+            "owner": n.owner,
+            "name": n.attrs.get("name") or n.attrs.get("title"),
+            "prunable": n.owner is None,
+        }
+        for n in gs.nodes()
+        if n.id not in endpoints
+    ]
+    return {"count": len(nodes), "nodes": nodes}
+
+
+def blame_session(gs, query: str) -> dict:
+    """What graph content session ``query`` produced or touched.
+
+    ``produced`` = nodes and edges the extraction stamped with this
+    session as ``owner`` (the session node itself, its tool_call nodes,
+    and every edge it emitted); ``touched`` = the shared entities those
+    edges reach — files, tools, projects, commits. ``session`` is
+    ``None`` when ``query`` matches nothing or is an ambiguous prefix —
+    ``candidates`` then lists session keys for the CLI to hint at.
+    """
+    node = gs.node(f"session:{query}")
+    candidates: list[str] = []
+    if node is None:
+        candidates = sorted(
+            n.key for n in gs.nodes("session") if n.key.startswith(query)
+        )
+        if len(candidates) == 1:
+            node = gs.node(f"session:{candidates[0]}")
+    if node is None:
+        return {
+            "query": query,
+            "session": None,
+            "candidates": candidates[:20],
+        }
+    sid = node.key
+    owned_nodes = [n for n in gs.nodes() if n.owner == sid]
+    owned_edges = [e for e in gs.edges() if e.owner == sid]
+    files = sorted(
+        {e.dst.split(":", 1)[1] for e in owned_edges
+         if e.kind == "file_touched"}
+    )
+    tools = sorted(
+        {e.dst.split(":", 1)[1] for e in owned_edges
+         if e.kind == "tool_used"}
+    )
+    projects = sorted(
+        {e.dst.split(":", 1)[1] for e in owned_edges
+         if e.kind == "runs_in"}
+    )
+    commits = [
+        {"sha": sha, "relation": rel}
+        for sha, rel in sorted(
+            {
+                (e.dst.split(":", 1)[1], e.kind)  # produced | referenced
+                for e in owned_edges
+                if e.kind in ("produced", "referenced")
+            }
+        )
+    ]
+    return {
+        "session_id": sid,
+        "session": _session_dict(gs, node),
+        "extracted_at": gs.extracted_at(sid),
+        "projects": projects,
+        "files": files,
+        "tools": tools,
+        "commits": commits,
+        "nodes_owned": [
+            {"id": n.id, "kind": n.kind, "key": n.key}
+            for n in owned_nodes
+        ],
+        "edges_owned": [
+            {"kind": e.kind, "src": e.src, "dst": e.dst}
+            for e in owned_edges
+        ],
+        "counts": {
+            "nodes": len(owned_nodes),
+            "edges": len(owned_edges),
+            "files": len(files),
+            "tools": len(tools),
+            "commits": len(commits),
+        },
+    }

{devin_graph-0.1.1 → devin_graph-0.1.2}/src/devin_graph/store.py

@@ -60,6 +60,7 @@ class StoredNode:
     kind: str
     key: str
     attrs: dict
+    owner: str | None = None  # session_id that produced the node
 
 
 @dataclass(frozen=True)
@@ -118,13 +119,14 @@ class GraphStore:
     # -- read API ------------------------------------------------------------
 
     def nodes(self, kind: str | None = None) -> list[StoredNode]:
-        sql = "SELECT id, kind, key, attrs FROM nodes"
+        sql = "SELECT id, kind, key, attrs, owner FROM nodes"
         args: tuple = ()
         if kind is not None:
             sql += " WHERE kind = ?"
             args = (kind,)
         return [
-            StoredNode(r["id"], r["kind"], r["key"], json.loads(r["attrs"]))
+            StoredNode(r["id"], r["kind"], r["key"],
+                       json.loads(r["attrs"]), r["owner"])
             for r in self._con.execute(sql + " ORDER BY id", args)
         ]
 
@@ -142,13 +144,13 @@ class GraphStore:
 
     def node(self, node_id: str) -> StoredNode | None:
         row = self._con.execute(
-            "SELECT id, kind, key, attrs FROM nodes WHERE id = ?",
+            "SELECT id, kind, key, attrs, owner FROM nodes WHERE id = ?",
             (node_id,),
         ).fetchone()
         if row is None:
             return None
         return StoredNode(row["id"], row["kind"], row["key"],
-                          json.loads(row["attrs"]))
+                          json.loads(row["attrs"]), row["owner"])
 
     def out_edges(self, node_id: str) -> list[StoredEdge]:
         return [
@@ -172,6 +174,16 @@ class GraphStore:
             )
         ]
 
+    def extracted_at(self, session_id: str) -> int | None:
+        """Ledger timestamp for ``session_id`` — when it was last
+        (re)extracted into this graph, or ``None``."""
+        row = self._con.execute(
+            "SELECT last_activity_at FROM extracted_sessions"
+            " WHERE session_id = ?",
+            (session_id,),
+        ).fetchone()
+        return row["last_activity_at"] if row else None
+
     # -- build ---------------------------------------------------------------
 
     def build(self, sessions_store,

{devin_graph-0.1.1 → devin_graph-0.1.2/src/devin_graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devin-graph
-Version: 0.1.1
+Version: 0.1.2
 Summary: Knowledge graph over Devin sessions — projects, files, tools and decisions as queryable nodes.
 Author: Icaro0310
 License: MIT
@@ -97,6 +97,10 @@ devin-graph query projects-graph           --graph graph.db --json
 
 # D3-friendly dump: {"meta", "nodes", "edges"}
 devin-graph export --format json --graph graph.db --out graph.json
+
+# diagnostics: edge-less nodes (report-only) and per-session blame
+devin-graph orphans                      --graph graph.db
+devin-graph blame-session <id-or-prefix> --graph graph.db
 ```
 
 Matching is forgiving (`src/app.py` finds `/repo/alpha/src/app.py`);
@@ -105,6 +109,15 @@ by two or more distinct projects, with the project and session lists —
 exportable as JSON like the other queries. The source DB is opened
 `mode=ro` and never written — tests assert its hash is unchanged.
 
+`orphans` lists nodes with no incident edges (id, kind, owner, a
+`prunable` flag marking the subset the next `build` would drop —
+shared, ownerless nodes; owned orphans persist with their owner). It is
+report-only and never deletes. `blame-session <id>` shows what a
+session produced and touched: its owned nodes and edges plus the
+resolved files, tools, projects and commits reachable through them,
+with the extraction-ledger timestamp. `<id>` accepts a unique prefix;
+a missing or ambiguous match exits 2 and lists candidates.
+
 ## Works with Devin alone (Devin-only mode)
 
 devin-graph builds `graph.db` locally from Devin's session stores — the whole

{devin_graph-0.1.1 → devin_graph-0.1.2}/src/devin_graph.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ tests/test_cli.py
 tests/test_extract.py
 tests/test_mcp.py
 tests/test_offline_core.py
+tests/test_orphans_blame.py
 tests/test_paths.py
 tests/test_query.py
 tests/test_skill.py

{devin_graph-0.1.1 → devin_graph-0.1.2}/tests/test_cli.py

@@ -7,6 +7,7 @@ import pytest
 from conftest import ALPHA
 from devin_graph.cli import main
 from devin_internals.fixtures import create_sessions_db
+from devin_internals.schema import LATEST_KNOWN_SCHEMA
 
 
 @pytest.fixture
@@ -123,7 +124,9 @@ def test_cli_export_stdout(built, capsys):
     assert main(["export", "--format", "json", "--graph", str(graph)]) == 0
     data = json.loads(capsys.readouterr().out)
     assert len(data["nodes"]) == 20 and len(data["edges"]) == 25
-    assert data["meta"]["schema_version"] == 17
+    # fixture emits the installed spec's latest schema (v17 at 0.3.1,
+    # v18 at 0.3.3) — pin to the constant, not a literal
+    assert data["meta"]["schema_version"] == LATEST_KNOWN_SCHEMA
 
 
 def test_cli_export_out_file(built, tmp_path, capsys):
@@ -145,7 +148,7 @@ def test_cli_missing_sessions_db(tmp_path, capsys):
 
 
 def test_cli_unknown_schema_fails_loud(tmp_path, capsys):
-    bad = create_sessions_db(tmp_path / "future.db", schema_version=18)
+    bad = create_sessions_db(tmp_path / "future.db", schema_version=LATEST_KNOWN_SCHEMA + 1)
     with pytest.raises(SystemExit) as exc:
         main(["build", "--sessions-db", str(bad),
               "--graph", str(tmp_path / "g.db")])

{devin_graph-0.1.1 → devin_graph-0.1.2}/tests/test_offline_core.py

@@ -26,6 +26,7 @@ import socket
 
 import pytest
 from devin_graph.cli import main
+from devin_internals.schema import LATEST_KNOWN_SCHEMA
 
 
 class OfflineCoreError(RuntimeError):
@@ -67,7 +68,9 @@ def test_build_and_export_offline(sessions_db, tmp_path, capsys):
     assert main(["export", "--format", "json", "--graph", str(graph)]) == 0
     data = json.loads(capsys.readouterr().out)
     assert len(data["nodes"]) > 0 and len(data["edges"]) > 0
-    assert data["meta"]["schema_version"] == 17
+    # fixture emits the installed spec's latest schema (v17 at 0.3.1,
+    # v18 at 0.3.3) — pin to the constant, not a literal
+    assert data["meta"]["schema_version"] == LATEST_KNOWN_SCHEMA
 
 
 def test_query_offline(sessions_db, tmp_path, capsys):

devin_graph-0.1.2/tests/test_orphans_blame.py

@@ -0,0 +1,160 @@
+"""``graph orphans`` + ``graph blame-session`` — report-only diagnostics."""
+
+import json
+import sqlite3
+
+import pytest
+from conftest import ALPHA
+from devin_graph.cli import main
+from devin_graph.query import blame_session, orphaned_nodes
+from devin_graph.store import GraphStore
+from devin_internals.parsers import SessionsStore
+
+
+@pytest.fixture
+def graph_path(sessions_db, tmp_path):
+    p = tmp_path / "graph.db"
+    with SessionsStore(sessions_db) as ss, GraphStore(p) as gs:
+        gs.build(ss)
+    return p
+
+
+def _insert_orphan(graph_path, node_id="file:/ghost", owner=None):
+    """An edgeless shared node straight into the db — the fixture graph
+    prunes real orphans at build time, so the only way to see one is to
+    write it after the build."""
+    con = sqlite3.connect(graph_path)
+    with con:
+        con.execute(
+            "INSERT INTO nodes(id, kind, key, owner, attrs)"
+            " VALUES (?, ?, ?, ?, '{}')",
+            (node_id, "file", node_id.split(":", 1)[1], owner),
+        )
+    con.close()
+
+
+# -- orphaned_nodes ------------------------------------------------------------
+
+
+def test_orphans_empty_in_healthy_graph(graph_path):
+    with GraphStore(graph_path, readonly=True) as gs:
+        data = orphaned_nodes(gs)
+    assert data == {"count": 0, "nodes": []}
+
+
+def test_orphans_reports_and_marks_prunable(graph_path):
+    _insert_orphan(graph_path)
+    with GraphStore(graph_path, readonly=True) as gs:
+        data = orphaned_nodes(gs)
+    assert data["count"] == 1
+    (n,) = data["nodes"]
+    assert n["id"] == "file:/ghost"
+    assert n["kind"] == "file" and n["owner"] is None
+    assert n["prunable"] is True
+
+
+def test_orphans_report_only_never_deletes(graph_path):
+    _insert_orphan(graph_path)
+    with GraphStore(graph_path, readonly=True) as gs:
+        orphaned_nodes(gs)
+    con = sqlite3.connect(graph_path)
+    try:
+        assert con.execute(
+            "SELECT COUNT(*) FROM nodes WHERE id = 'file:/ghost'"
+        ).fetchone()[0] == 1
+    finally:
+        con.close()
+
+
+def test_owned_orphan_not_prunable(graph_path):
+    # an owner-carried orphan persists until its owner re-extracts —
+    # report it, but flag it as kept-by-prune.
+    _insert_orphan(graph_path, "session:ghost-sess", owner="ghost-sess")
+    with GraphStore(graph_path, readonly=True) as gs:
+        data = orphaned_nodes(gs)
+    (n,) = data["nodes"]
+    assert n["prunable"] is False and n["owner"] == "ghost-sess"
+
+
+# -- blame_session --------------------------------------------------------------
+
+
+def test_blame_session_contents(graph_path):
+    with GraphStore(graph_path, readonly=True) as gs:
+        data = blame_session(gs, "sess-a")
+    s = data["session"]
+    assert s["title"] == "Alpha work"
+    assert data["projects"] == [ALPHA]
+    assert data["extracted_at"] is not None
+    # produced: 1 session node + 3 tool_call nodes
+    kinds = [n["kind"] for n in data["nodes_owned"]]
+    assert kinds.count("session") == 1 and kinds.count("tool_call") == 3
+    assert data["counts"]["nodes"] == 4
+    # touched: the read of ALPHA/src/app.py (resolve joins it under cwd)
+    assert f"{ALPHA}/src/app.py" in data["files"]
+    assert data["counts"]["files"] == len(data["files"])
+    # edges: runs_in + 3× made_call + call_used/tool_used/file_touched
+    assert data["counts"]["edges"] == len(data["edges_owned"])
+    assert any(e["kind"] == "runs_in" for e in data["edges_owned"])
+    assert any(e["kind"] == "file_touched" for e in data["edges_owned"])
+
+
+def test_blame_session_no_match(graph_path):
+    with GraphStore(graph_path, readonly=True) as gs:
+        data = blame_session(gs, "zzz")
+    assert data["session"] is None
+    assert data["candidates"] == []
+
+
+def test_blame_session_ambiguous_prefix(graph_path):
+    with GraphStore(graph_path, readonly=True) as gs:
+        data = blame_session(gs, "sess")
+    assert data["session"] is None
+    assert set(data["candidates"]) == {"sess-a", "sess-b", "sess-c"}
+
+
+# -- CLI ------------------------------------------------------------------------
+
+
+def test_cli_orphans_empty(graph_path, capsys):
+    assert main(["orphans", "--graph", str(graph_path)]) == 0
+    assert "no orphaned nodes" in capsys.readouterr().out
+
+
+def test_cli_orphans_json(graph_path, capsys):
+    _insert_orphan(graph_path)
+    assert main(["orphans", "--graph", str(graph_path), "--json"]) == 0
+    data = json.loads(capsys.readouterr().out)
+    assert data["count"] == 1
+    assert data["nodes"][0]["id"] == "file:/ghost"
+
+
+def test_cli_blame_text(graph_path, capsys):
+    assert main(["blame-session", "sess-b", "--graph", str(graph_path)]) == 0
+    out = capsys.readouterr().out
+    assert "Beta work" in out
+    assert "produced:" in out and "touched:" in out
+    assert f"{ALPHA}/src/app.py" in out  # shared file sess-b also read
+
+
+def test_cli_blame_json(graph_path, capsys):
+    assert main(
+        ["blame-session", "sess-c", "--graph", str(graph_path), "--json"]
+    ) == 0
+    data = json.loads(capsys.readouterr().out)
+    assert data["session_id"] == "sess-c"
+    assert data["session"]["title"] == "Alpha docs"
+    assert data["counts"]["nodes"] >= 2
+
+
+def test_cli_blame_no_match_exit_2(graph_path, capsys):
+    rc = main(["blame-session", "nope", "--graph", str(graph_path)])
+    assert rc == 2
+    assert "no session matches" in capsys.readouterr().err
+
+
+def test_cli_blame_ambiguous_lists_candidates(graph_path, capsys):
+    rc = main(["blame-session", "sess", "--graph", str(graph_path)])
+    assert rc == 2
+    err = capsys.readouterr().err
+    assert "sess-a" in err and "sess-b" in err

{devin_graph-0.1.1 → devin_graph-0.1.2}/tests/test_store.py

@@ -6,6 +6,7 @@ import sqlite3
 from conftest import ALPHA, BETA, add_tool_call, bump_last_activity, delete_session
 from devin_graph.store import GraphStore
 from devin_internals.parsers import SessionsStore
+from devin_internals.schema import LATEST_KNOWN_SCHEMA
 
 EXPECTED_NODE_COUNTS = {
     "session": 3, "project": 2, "tool": 4, "tool_call": 6, "file": 5}
@@ -95,7 +96,9 @@ def test_export_json_shape(sessions_db, tmp_path):
         data = gs.export()
 
     assert set(data) == {"meta", "nodes", "edges"}
-    assert data["meta"]["schema_version"] == 17
+    # fixture emits the installed spec's latest schema (v17 at 0.3.1,
+    # v18 at 0.3.3) — pin to the constant, not a literal
+    assert data["meta"]["schema_version"] == LATEST_KNOWN_SCHEMA
     json.dumps(data)  # must be JSON-serializable
 
     node = next(n for n in data["nodes"] if n["id"] == "session:sess-a")

devin_graph-0.1.1/src/devin_graph/__init__.py

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