reactifact 0.6.0__py3-none-any.whl

reactifact/checkpoints.py

@@ -0,0 +1,329 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import sqlite3
+import time
+import urllib.parse
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, cast
+
+
+class CheckpointBackend(ABC):
+    """Interface for saving and loading the Workspace state (single blob)."""
+
+    @abstractmethod
+    async def save(self, data: dict[str, Any]) -> None:
+        """Saves the state dictionary."""
+        ...
+
+    @abstractmethod
+    async def load(self) -> dict[str, Any]:
+        """Loads the state dictionary."""
+        ...
+
+    async def aclose(self) -> None:  # noqa: B027
+        """Releases held resources (a pooled connection, ...). No-op by default."""
+
+
+class KVBackend(ABC):
+    """Key-value store. Used for sessions (session_id → Context)."""
+
+    @abstractmethod
+    async def set(self, key: str, data: dict[str, Any]) -> None: ...
+
+    @abstractmethod
+    async def get(self, key: str) -> dict[str, Any] | None: ...
+
+    @abstractmethod
+    async def delete(self, key: str) -> None: ...
+
+    @abstractmethod
+    async def keys(self) -> list[str]: ...
+
+    async def aclose(self) -> None:  # noqa: B027
+        """Releases held resources (a pooled connection, ...). No-op by default."""
+
+
+class FileKVBackend(KVBackend):
+    """File KV backend: one JSON file per key in a directory.
+
+    Every call offloads its blocking filesystem I/O to a worker thread
+    (`asyncio.to_thread`) so it never stalls the event loop reactifact's runtime
+    and chat/web layers run on.
+    """
+
+    def __init__(self, directory: str):
+        self.directory = Path(directory)
+
+    def _path(self, key: str) -> Path:
+        safe = urllib.parse.quote(key, safe="")
+        return self.directory / f"{safe}.json"
+
+    def _set_sync(self, key: str, data: dict[str, Any]) -> None:
+        self.directory.mkdir(parents=True, exist_ok=True)
+        path = self._path(key)
+        tmp = path.with_suffix(".tmp")
+        # json.dumps() + one write(), not json.dump(obj, f): CPython's
+        # json.dump() streams via JSONEncoder.iterencode(), which — unlike
+        # .encode() (what dumps() calls) — never takes the C-accelerated
+        # encoder path, so it's the pure-Python encoder walking the whole
+        # object graph node by node. For a large session (thousands of
+        # artifacts/commits, written on every save — see reactifact/session.py)
+        # that's a real, measured ~5-10x difference on identical content.
+        payload = json.dumps({"key": key, "data": data})
+        with open(tmp, "w", encoding="utf-8") as f:
+            f.write(payload)
+        tmp.replace(path)
+
+    async def set(self, key: str, data: dict[str, Any]) -> None:
+        await asyncio.to_thread(self._set_sync, key, data)
+
+    def _get_sync(self, key: str) -> dict[str, Any] | None:
+        path = self._path(key)
+        if not path.exists():
+            return None
+        with open(path, encoding="utf-8") as f:
+            return cast(dict[str, Any] | None, json.load(f).get("data"))
+
+    async def get(self, key: str) -> dict[str, Any] | None:
+        return await asyncio.to_thread(self._get_sync, key)
+
+    def _delete_sync(self, key: str) -> None:
+        path = self._path(key)
+        if path.exists():
+            path.unlink()
+
+    async def delete(self, key: str) -> None:
+        await asyncio.to_thread(self._delete_sync, key)
+
+    def _keys_sync(self) -> list[str]:
+        self.directory.mkdir(parents=True, exist_ok=True)
+        return [
+            urllib.parse.unquote(p.stem) for p in sorted(self.directory.glob("*.json"))
+        ]
+
+    async def keys(self) -> list[str]:
+        return await asyncio.to_thread(self._keys_sync)
+
+
+class FileBackend(CheckpointBackend):
+    """File backend: state is stored in a single JSON file."""
+
+    def __init__(self, path: str):
+        self.path = path
+
+    def _save_sync(self, data: dict[str, Any]) -> None:
+        with open(self.path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+
+    async def save(self, data: dict[str, Any]) -> None:
+        await asyncio.to_thread(self._save_sync, data)
+
+    def _load_sync(self) -> dict[str, Any]:
+        with open(self.path, encoding="utf-8") as f:
+            return cast(dict[str, Any], json.load(f))
+
+    async def load(self) -> dict[str, Any]:
+        return await asyncio.to_thread(self._load_sync)
+
+
+class _AsyncSQLite:
+    """One persistent `sqlite3.Connection` per backend instance, guarded by an
+    `asyncio.Lock` and run off-thread via `asyncio.to_thread`.
+
+    Reconnecting on every call (the previous behavior) meant every checkpoint
+    write paid a fresh `connect()`, and concurrent writers had no `busy_timeout`
+    to wait out a lock — they just raised `sqlite3.OperationalError: database is
+    locked`. WAL mode lets readers and the single writer overlap; the lock here
+    only serializes access from *this process* (SQLite itself still serializes
+    writers across processes via the database file).
+    """
+
+    def __init__(self, db_path: str, init_sql: str):
+        self.db_path = db_path
+        self._init_sql = init_sql
+        self._conn: sqlite3.Connection | None = None
+        self._lock = asyncio.Lock()
+
+    def _connect(self) -> sqlite3.Connection:
+        # `busy_timeout` only takes effect once set on *this* connection, so
+        # the pragmas below race the very connections that would honor it —
+        # switching journal mode is an exclusive operation SQLite does not
+        # always retry through the normal busy handler. Several backends
+        # opening a brand-new file at once can still hit `database is
+        # locked` here; retry the one-time bootstrap instead of the hot path.
+        conn = sqlite3.connect(self.db_path, check_same_thread=False, timeout=5.0)
+        attempts = 0
+        while True:
+            try:
+                conn.execute("PRAGMA journal_mode=WAL")
+                conn.execute("PRAGMA busy_timeout=5000")
+                conn.execute(self._init_sql)
+                conn.commit()
+                return conn
+            except sqlite3.OperationalError:
+                attempts += 1
+                if attempts >= 10:
+                    raise
+                time.sleep(0.05 * attempts)
+
+    def _exec(self, sql: str, params: tuple[Any, ...]) -> list[tuple[Any, ...]]:
+        assert self._conn is not None
+        cur = self._conn.execute(sql, params)
+        self._conn.commit()
+        return cur.fetchall()
+
+    async def execute(
+        self, sql: str, params: tuple[Any, ...] = ()
+    ) -> list[tuple[Any, ...]]:
+        async with self._lock:
+            if self._conn is None:
+                self._conn = await asyncio.to_thread(self._connect)
+            return await asyncio.to_thread(self._exec, sql, params)
+
+    async def aclose(self) -> None:
+        async with self._lock:
+            if self._conn is not None:
+                await asyncio.to_thread(self._conn.close)
+                self._conn = None
+
+
+class SQLiteKVBackend(KVBackend):
+    """SQLite KV backend: table kv_entries(key PRIMARY KEY, data JSON)."""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self._sql = _AsyncSQLite(
+            db_path,
+            "CREATE TABLE IF NOT EXISTS kv_entries "
+            "(key TEXT PRIMARY KEY, data TEXT NOT NULL)",
+        )
+
+    async def set(self, key: str, data: dict[str, Any]) -> None:
+        await self._sql.execute(
+            "INSERT OR REPLACE INTO kv_entries (key, data) VALUES (?, ?)",
+            (key, json.dumps(data)),
+        )
+
+    async def get(self, key: str) -> dict[str, Any] | None:
+        rows = await self._sql.execute(
+            "SELECT data FROM kv_entries WHERE key = ?", (key,)
+        )
+        return cast(dict[str, Any], json.loads(rows[0][0])) if rows else None
+
+    async def delete(self, key: str) -> None:
+        await self._sql.execute("DELETE FROM kv_entries WHERE key = ?", (key,))
+
+    async def keys(self) -> list[str]:
+        rows = await self._sql.execute("SELECT key FROM kv_entries")
+        return [cast(str, r[0]) for r in rows]
+
+    async def aclose(self) -> None:
+        await self._sql.aclose()
+
+
+class SQLiteBackend(CheckpointBackend):
+    """SQLite backend: state is stored in the checkpoint table (single row)."""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self._sql = _AsyncSQLite(
+            db_path,
+            "CREATE TABLE IF NOT EXISTS checkpoint "
+            "(id INTEGER PRIMARY KEY CHECK (id = 1), data TEXT NOT NULL)",
+        )
+
+    async def save(self, data: dict[str, Any]) -> None:
+        await self._sql.execute(
+            "INSERT OR REPLACE INTO checkpoint (id, data) VALUES (1, ?)",
+            (json.dumps(data),),
+        )
+
+    async def load(self) -> dict[str, Any]:
+        rows = await self._sql.execute("SELECT data FROM checkpoint WHERE id = 1")
+        if not rows:
+            raise ValueError(f"Checkpoint not found in SQLite database: {self.db_path}")
+        return cast(dict[str, Any], json.loads(rows[0][0]))
+
+    async def aclose(self) -> None:
+        await self._sql.aclose()
+
+
+class PostgreSQLKVBackend(KVBackend):
+    """PostgreSQL KV backend (`kv_entries(key, data)`) — behind the `pg` extra.
+
+    Like the SQLite KV backend, but shared across processes: a natural store
+    when sessions are persisted in the same Postgres as the application. The
+    driver (`psycopg`) is imported lazily so the core stays dependency-free;
+    install it with `uv sync --extra pg` (or group `pg`).
+
+    Uses psycopg3's native async API (`AsyncConnection`) over one persistent,
+    lazily-(re)connected connection, serialized by an `asyncio.Lock` — the same
+    shape as `SQLiteKVBackend`. A dedicated connection per backend instance is
+    enough for session-checkpoint traffic (small, infrequent writes); reach for
+    `psycopg_pool.AsyncConnectionPool` yourself if you need many concurrent
+    writers sharing one DSN.
+    """
+
+    def __init__(self, dsn: str):
+        from ._extras import require_extra
+
+        self._psycopg = require_extra("PostgreSQLKVBackend", "psycopg", "pg")
+        self.dsn = dsn
+        self._conn: Any | None = None
+        self._lock = asyncio.Lock()
+
+    async def _connection(self) -> Any:
+        conn = self._conn
+        if conn is None or conn.closed:
+            conn = await self._psycopg.AsyncConnection.connect(self.dsn)
+            async with conn.cursor() as cur:
+                await cur.execute(
+                    "CREATE TABLE IF NOT EXISTS kv_entries "
+                    "(key TEXT PRIMARY KEY, data TEXT NOT NULL)"
+                )
+            await conn.commit()
+            self._conn = conn
+        return conn
+
+    async def set(self, key: str, data: dict[str, Any]) -> None:
+        async with self._lock:
+            conn = await self._connection()
+            async with conn.cursor() as cur:
+                await cur.execute(
+                    "INSERT INTO kv_entries (key, data) VALUES (%s, %s) "
+                    "ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data",
+                    (key, json.dumps(data)),
+                )
+            await conn.commit()
+
+    async def get(self, key: str) -> dict[str, Any] | None:
+        async with self._lock:
+            conn = await self._connection()
+            async with conn.cursor() as cur:
+                await cur.execute("SELECT data FROM kv_entries WHERE key = %s", (key,))
+                row = await cur.fetchone()
+        return cast(dict[str, Any], json.loads(row[0])) if row is not None else None
+
+    async def delete(self, key: str) -> None:
+        async with self._lock:
+            conn = await self._connection()
+            async with conn.cursor() as cur:
+                await cur.execute("DELETE FROM kv_entries WHERE key = %s", (key,))
+            await conn.commit()
+
+    async def keys(self) -> list[str]:
+        async with self._lock:
+            conn = await self._connection()
+            async with conn.cursor() as cur:
+                await cur.execute("SELECT key FROM kv_entries")
+                rows = await cur.fetchall()
+        return [cast(str, r[0]) for r in rows]
+
+    async def aclose(self) -> None:
+        async with self._lock:
+            if self._conn is not None and not self._conn.closed:
+                await self._conn.close()
+            self._conn = None

reactifact/cli/__init__.py

@@ -0,0 +1,73 @@
+"""python -m reactifact — inspect & visualize the runtime as Mermaid.
+
+Subcommands:
+
+    graph    static agent blueprint from a module path ("pkg.mod:Attr")
+    context  live provenance graph from a saved session (KV backend)
+    trace    run diagram from a trace store (SQLite)
+    replay   deterministic state replay of a saved session
+    branch   persistent forks over a KV backend
+    scenario run reactifact.testing scenarios (separate from pytest)
+
+Examples:
+
+    python -m reactifact graph examples.knowledge.agents
+    python -m reactifact context examples/knowledge/sessions/traces.sqlite3
+    python -m reactifact trace traces.db
+
+Everything prints Mermaid source to stdout — paste it into GitHub, Notion or
+mermaid.live.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .. import __version__
+from . import branch, context, graph, replay, scenario, trace
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="reactifact",
+        description="Inspect & visualize reactifact agents, contexts and traces as Mermaid.",
+    )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    for module in (graph, context, trace, replay, branch, scenario):
+        module.add_parser(sub)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    # Make local modules importable the same way `python -m reactifact` does —
+    # the installed console-script entry point doesn't prepend cwd on its own.
+    if "" not in sys.path:
+        sys.path.insert(0, "")
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.command is None:
+        print(
+            f"reactifact {__version__} — inspect & visualize agents, contexts and"
+            " traces as Mermaid.\n"
+        )
+        print("Render what your agent app already did:")
+        print("  reactifact graph   <module:Agent>   static blueprint")
+        print("  reactifact trace   <trace.db>       run diagram")
+        print("  reactifact context <sessions.sqlite3>  live provenance graph")
+        print("  reactifact replay  <sessions.sqlite3>  deterministic replay")
+        print("  reactifact branch  <path> <session> <action>  persistent forks")
+        print("  reactifact scenario <module>  run reactifact.testing scenarios\n")
+        print("Run 'reactifact <command> --help' for details, or try an example:")
+        print("  uv run python ./examples/llm_ladder/level1.py")
+        parser.print_help()
+        return 0
+    return int(args.func(args))

reactifact/cli/branch.py

@@ -0,0 +1,77 @@
+"""`reactifact branch` — persistent forks over a KV backend (§39-§40)."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+
+from .common import open_store
+
+
+async def _cmd_branch(args: argparse.Namespace) -> int:
+    from ..branching import BranchStore
+    from ..session import SessionStore
+
+    store = SessionStore(open_store(args.path, args.backend))
+    branches = BranchStore(store.backend)
+
+    if args.action == "list":
+        names = await branches.list_branches(args.session)
+        stat = f"branches of {args.session!r}: " + (
+            ", ".join(names) if names else "none"
+        )
+        print(stat)
+        return 0
+
+    if args.action == "save":
+        context = await store.load_session(args.session)
+        if context is None:
+            print(f"session {args.session!r} not found")
+            return 1
+        await branches.save_branch(context, session_id=args.session, name=args.name)
+        print(f"saved branch {args.session!r}:{args.name}")
+        return 0
+
+    # merge
+    into = await branches.load_branch(args.session, args.into)
+    source = await branches.load_branch(args.session, args.source)
+    if into is None or source is None:
+        print("missing branch (use 'branch list')")
+        return 1
+    try:
+        into.merge(source)
+    except Exception as exc:  # MergeConflict and friends
+        print(str(exc))
+        return 1
+    if args.as_name:
+        await branches.save_branch(into, session_id=args.session, name=args.as_name)
+        print(f"merged into {args.session!r}:{args.as_name}")
+    else:
+        await branches.save_branch(into, session_id=args.session, name=args.into)
+        print(f"merged {args.session!r}:{args.source} into {args.into}")
+    return 0
+
+
+def cmd_branch(args: argparse.Namespace) -> int:
+    return asyncio.run(_cmd_branch(args))
+
+
+def add_parser(sub: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    p_branch = sub.add_parser(
+        "branch", help="persistent forks over a KV backend (§39-§40)"
+    )
+    p_branch.add_argument(
+        "path", help="KV backend file (sessions.sqlite3) or directory"
+    )
+    p_branch.add_argument("session", help="session id")
+    p_branch.add_argument(
+        "action", choices=["list", "save", "merge"], help="what to do"
+    )
+    p_branch.add_argument("name", nargs="?", default=None, help="name (save)")
+    p_branch.add_argument("--into", default=None, help="merge target branch")
+    p_branch.add_argument("--source", default=None, help="merge source branch")
+    p_branch.add_argument(
+        "--as", dest="as_name", default=None, help="result branch name"
+    )
+    p_branch.add_argument("--backend", choices=["file", "sqlite"], default="auto")
+    p_branch.set_defaults(func=cmd_branch)

reactifact/cli/common.py

@@ -0,0 +1,67 @@
+"""Shared helpers for CLI subcommands: module-path agent loading, KV-backend
+opening by path/extension. No argparse wiring here — see each subcommand
+module for that."""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+from ..agents import Agent
+
+if TYPE_CHECKING:
+    from ..checkpoints import FileKVBackend, SQLiteKVBackend
+
+
+def load_agents(spec: str) -> list[Agent]:
+    module_name, has_attr, attr = spec.partition(":")
+    try:
+        module = importlib.import_module(module_name)
+    except ModuleNotFoundError as exc:
+        raise SystemExit(
+            f"could not import {module_name!r}: {exc}. If this is a local "
+            "module (not installed as a package), run via "
+            f"`uv run python -m reactifact graph {spec}` instead."
+        ) from exc
+    if has_attr:
+        obj = getattr(module, attr)
+        if isinstance(obj, Agent):
+            return [obj]
+        if isinstance(obj, (list, tuple)):
+            if not obj:
+                raise SystemExit(f"{spec!r} resolved to an empty list")
+            agents = [o for o in obj if isinstance(o, Agent)]
+            if len(agents) != len(obj):
+                raise SystemExit(
+                    f"{spec!r} must resolve to an Agent or a list of Agents"
+                )
+            return agents
+        raise SystemExit(f"expected an Agent or list[Agent] at {spec!r}")
+
+    agents = [value for value in vars(module).values() if isinstance(value, Agent)]
+    if not agents:
+        # The demos instantiate their agents inline — synthesize the blueprint
+        # from every Agent subclass defined in the module (stateless containers).
+        classes = [
+            value
+            for _name, value in sorted(vars(module).items())
+            if isinstance(value, type)
+            and issubclass(value, Agent)
+            and value is not Agent
+            and value.__module__ == module_name
+        ]
+        agents = [cls() for cls in classes]
+    if not agents:
+        raise SystemExit(
+            f"no Agent instances or subclasses found in {module_name!r}; "
+            'use the "module:Attr" form'
+        )
+    return agents
+
+
+def open_store(path: str, backend: str) -> FileKVBackend | SQLiteKVBackend:
+    from ..checkpoints import FileKVBackend, SQLiteKVBackend
+
+    if backend == "sqlite" or path.endswith((".db", ".sqlite", ".sqlite3")):
+        return SQLiteKVBackend(path)
+    return FileKVBackend(path)

reactifact/cli/context.py

@@ -0,0 +1,53 @@
+"""`reactifact context` — live provenance graph from a saved session."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+
+from .common import open_store
+
+
+async def _cmd_context(args: argparse.Namespace) -> int:
+    import sqlite3
+
+    from ..session import SessionStore
+    from ..viz import context_to_mermaid
+
+    try:
+        store = SessionStore(open_store(args.path, args.backend))
+        sessions = await store.list_sessions()
+    except sqlite3.OperationalError:
+        print(f"no session store found at {args.path!r}")
+        return 1
+    if not sessions:
+        print("no sessions found")
+        return 1
+    session_id = args.session or sessions[-1]
+    context = await store.load_session(session_id)
+    if context is None:
+        print(f"session {session_id!r} not found")
+        return 1
+    print(context_to_mermaid(context, limit=args.limit))
+    return 0
+
+
+def cmd_context(args: argparse.Namespace) -> int:
+    return asyncio.run(_cmd_context(args))
+
+
+def add_parser(sub: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    p_context = sub.add_parser(
+        "context", help="live provenance graph of a saved session"
+    )
+    p_context.add_argument(
+        "path", help="KV backend file (sessions.sqlite3) or directory"
+    )
+    p_context.add_argument(
+        "--session", default=None, help="session id (default: latest)"
+    )
+    p_context.add_argument("--backend", choices=["file", "sqlite"], default="auto")
+    p_context.add_argument(
+        "--limit", type=int, default=None, help="max artifacts shown"
+    )
+    p_context.set_defaults(func=cmd_context)

reactifact/cli/graph.py

@@ -0,0 +1,21 @@
+"""`reactifact graph` — static agent blueprint from a module path."""
+
+from __future__ import annotations
+
+import argparse
+
+from ..viz import blueprint
+from .common import load_agents
+
+
+def cmd_graph(args: argparse.Namespace) -> int:
+    agents = load_agents(args.agents)
+    print(blueprint(agents, title=args.title))
+    return 0
+
+
+def add_parser(sub: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    p_graph = sub.add_parser("graph", help="static agent blueprint")
+    p_graph.add_argument("agents", help='module path, e.g. "examples.knowledge.agents"')
+    p_graph.add_argument("--title", default="reactifact blueprint")
+    p_graph.set_defaults(func=cmd_graph)

reactifact/cli/replay.py

@@ -0,0 +1,69 @@
+"""`reactifact replay` — deterministic state replay of a saved session (§55)."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+
+from .common import open_store
+
+
+async def _cmd_replay(args: argparse.Namespace) -> int:
+    import sqlite3
+
+    from ..replay import replay_context, replay_summary
+    from ..session import SessionStore
+
+    try:
+        store = SessionStore(open_store(args.path, args.backend))
+        sessions = await store.list_sessions()
+    except sqlite3.OperationalError:
+        print(f"no session store found at {args.path!r}")
+        return 1
+    if not sessions:
+        print("no sessions found")
+        return 1
+    session_id = args.session or sessions[-1]
+    try:
+        context = await replay_context(store, session_id, version=args.version)
+    except KeyError as exc:
+        print(str(exc))
+        return 1
+    summary = replay_summary(context)
+    print(f"session {session_id!r} — replay v{summary['version']}")
+    print(
+        f"artifacts: {summary['artifacts']} · relations: {summary['relations']} · "
+        f"pending questions: {summary['pending_questions']}"
+    )
+    for tname, count in sorted(summary["by_type"].items()):
+        print(f"  {tname}: {count}")
+    if args.diagram:
+        from ..viz import context_to_mermaid
+
+        print()
+        print(context_to_mermaid(context))
+    return 0
+
+
+def cmd_replay(args: argparse.Namespace) -> int:
+    return asyncio.run(_cmd_replay(args))
+
+
+def add_parser(sub: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    p_replay = sub.add_parser(
+        "replay", help="deterministic state replay of a saved session (§55)"
+    )
+    p_replay.add_argument(
+        "path", help="KV backend file (sessions.sqlite3) or directory"
+    )
+    p_replay.add_argument(
+        "--session", default=None, help="session id (default: latest)"
+    )
+    p_replay.add_argument(
+        "--version", type=int, default=None, help="replay to this commit"
+    )
+    p_replay.add_argument("--backend", choices=["file", "sqlite"], default="auto")
+    p_replay.add_argument(
+        "--diagram", action="store_true", help="also print the provenance graph"
+    )
+    p_replay.set_defaults(func=cmd_replay)