generated from coulomb/repo-seed
210 lines
8.9 KiB
Python
210 lines
8.9 KiB
Python
import json
|
|
from pathlib import Path
|
|
|
|
from phase_memory.adapters import FileBackedMemoryGraphStore, JsonlAuditSink, JsonlMemoryEventLog, LOCAL_STORE_SCHEMA
|
|
from phase_memory.lifecycle import plan_compaction, plan_retention
|
|
from phase_memory.models import LifecycleAction, LifecycleActionKind, LifecycleState, MemoryEdge, MemoryEvent, MemoryNode
|
|
from phase_memory.paths import abandon_path, branch_path, create_path, merge_path, path_event
|
|
from phase_memory.runtime import PhaseMemoryRuntime
|
|
|
|
|
|
FIXTURES = Path(__file__).parent / "fixtures"
|
|
|
|
|
|
def _load(name: str):
|
|
return json.loads((FIXTURES / name).read_text(encoding="utf-8"))
|
|
|
|
|
|
def test_file_backed_store_round_trips_and_exports_graph(tmp_path) -> None:
|
|
store = FileBackedMemoryGraphStore(tmp_path)
|
|
event_log = JsonlMemoryEventLog(tmp_path / "events.jsonl")
|
|
runtime = PhaseMemoryRuntime(graph_store=store, event_log=event_log, audit_sink=JsonlAuditSink(tmp_path / "audit.jsonl"))
|
|
|
|
runtime.import_profile(_load("memory-profile.json"), source_ref="profile")
|
|
runtime.import_graph(_load("memory-graph.json"), source_ref="graph")
|
|
|
|
assert store.get_profile("phase-memory-fixture-profile").profile_id == "phase-memory-fixture-profile"
|
|
assert store.get_node("decision.boundary").kind == "decision"
|
|
assert store.list_edges(source="decision.boundary")[0].target == "artifact.profile"
|
|
|
|
exported = runtime.export_graph(graph_id="exported")["data"]["graph"]
|
|
assert exported["schema_version"] == "markitect.memory.graph.v1"
|
|
assert exported["id"] == "exported"
|
|
assert len(exported["nodes"]) == 4
|
|
assert len(exported["edges"]) == 2
|
|
assert len(exported["events"]) == 1
|
|
|
|
|
|
def test_jsonl_event_log_detects_duplicates_and_corruption(tmp_path) -> None:
|
|
log = JsonlMemoryEventLog(tmp_path / "events.jsonl")
|
|
event = MemoryEvent("event.a", "recorded", timestamp="2026-05-18T00:00:00+00:00")
|
|
|
|
log.append(event)
|
|
|
|
try:
|
|
log.append(event)
|
|
except ValueError as exc:
|
|
assert "Duplicate memory event id" in str(exc)
|
|
else:
|
|
raise AssertionError("duplicate event id should fail")
|
|
|
|
with (tmp_path / "events.jsonl").open("a", encoding="utf-8") as handle:
|
|
handle.write("{not-json}\n")
|
|
handle.write(json.dumps({"schema_version": "unknown.event.v9", "id": "event.b", "kind": "recorded"}) + "\n")
|
|
|
|
diagnostics = log.diagnostics()
|
|
assert [diagnostic.code for diagnostic in diagnostics] == ["malformed_event_log_line", "unknown_event_schema"]
|
|
assert log.list_events(kind="recorded")[0].event_id == "event.a"
|
|
|
|
|
|
def test_memory_paths_model_branch_merge_and_abandon_as_events(tmp_path) -> None:
|
|
store = FileBackedMemoryGraphStore(tmp_path)
|
|
root = create_path("path.root", event_ids=("event.root",))
|
|
branch = branch_path(root, "path.branch", event_ids=("event.branch",))
|
|
merged = merge_path(branch, "path.root")
|
|
abandoned = abandon_path(branch, "superseded by main path")
|
|
|
|
store.save_path(root)
|
|
store.save_path(merged)
|
|
|
|
assert store.get_path("path.branch").merged_into == "path.root"
|
|
assert path_event(merged, "path.merged").metadata["path_state"] == "merged"
|
|
assert abandoned.abandoned_reason == "superseded by main path"
|
|
|
|
|
|
def test_repair_diagnostics_report_missing_edges_and_orphaned_path_events(tmp_path) -> None:
|
|
store = FileBackedMemoryGraphStore(tmp_path)
|
|
log = JsonlMemoryEventLog(tmp_path / "events.jsonl")
|
|
runtime = PhaseMemoryRuntime(graph_store=store, event_log=log)
|
|
|
|
store.save_node(MemoryNode("node.a", "decision"))
|
|
store.save_edge(MemoryEdge("edge.bad", "depends_on", "node.a", "missing"))
|
|
store.save_path(create_path("path.root", event_ids=("missing.event",)))
|
|
|
|
envelope = runtime.repair_diagnostics(source_ref=str(tmp_path))
|
|
|
|
assert envelope["valid"] is False
|
|
assert [diagnostic["code"] for diagnostic in envelope["diagnostics"]] == ["missing_edge_target", "orphaned_path_event"]
|
|
|
|
|
|
def test_file_backed_store_reports_migration_needs_and_uses_atomic_json_writes(tmp_path) -> None:
|
|
store = FileBackedMemoryGraphStore(tmp_path)
|
|
metadata_path = tmp_path / "phase-memory.json"
|
|
metadata_path.write_text(
|
|
json.dumps(
|
|
{
|
|
"schema_version": "phase_memory.local_store.v0",
|
|
"planned_migrations": ["v0-to-v1"],
|
|
}
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
|
|
store.save_node(MemoryNode("node.atomic", "decision", "Atomic write target"))
|
|
runtime = PhaseMemoryRuntime(graph_store=store, event_log=JsonlMemoryEventLog(tmp_path / "events.jsonl"))
|
|
|
|
envelope = runtime.repair_diagnostics(source_ref=str(tmp_path))
|
|
|
|
codes = [diagnostic["code"] for diagnostic in envelope["diagnostics"]]
|
|
assert envelope["valid"] is True
|
|
assert "store_migration_required" in codes
|
|
assert "planned_store_migrations" in codes
|
|
assert not list(tmp_path.rglob("*.tmp"))
|
|
|
|
|
|
def test_local_store_migration_apply_updates_metadata_and_audits(tmp_path) -> None:
|
|
store = FileBackedMemoryGraphStore(tmp_path)
|
|
runtime = PhaseMemoryRuntime(graph_store=store, event_log=JsonlMemoryEventLog(tmp_path / "events.jsonl"))
|
|
(tmp_path / "phase-memory.json").write_text(
|
|
json.dumps(
|
|
{
|
|
"schema_version": "phase_memory.local_store.v0",
|
|
"planned_migrations": ["v0-to-v1"],
|
|
}
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
|
|
planned = runtime.plan_store_migration(source_ref=str(tmp_path))
|
|
applied = runtime.apply_store_migration(planned["data"]["migration_plan"], actor="pytest", source_ref=str(tmp_path))
|
|
metadata = store.metadata()
|
|
audit = runtime.query_audit({"operation": "store.migration.apply", "dry_run": False})
|
|
|
|
assert planned["valid"] is True
|
|
assert [action["action"] for action in planned["data"]["migration_plan"]["actions"]] == [
|
|
"set_schema_version",
|
|
"complete_planned_migration",
|
|
]
|
|
assert applied["valid"] is True
|
|
assert applied["data"]["migration_result"]["changed"] is True
|
|
assert metadata["schema_version"] == LOCAL_STORE_SCHEMA
|
|
assert metadata["completed_migrations"] == ["v0-to-v1"]
|
|
assert metadata["last_migration"]["actor"] == "pytest"
|
|
assert audit["count"] == 1
|
|
|
|
|
|
def test_local_store_migration_noop_and_corrupt_metadata_paths(tmp_path) -> None:
|
|
store = FileBackedMemoryGraphStore(tmp_path)
|
|
runtime = PhaseMemoryRuntime(graph_store=store, event_log=JsonlMemoryEventLog(tmp_path / "events.jsonl"))
|
|
|
|
noop = runtime.apply_store_migration(source_ref=str(tmp_path))
|
|
assert noop["valid"] is True
|
|
assert noop["data"]["migration_result"]["changed"] is False
|
|
|
|
(tmp_path / "phase-memory.json").write_text("{not-json}\n", encoding="utf-8")
|
|
planned = runtime.plan_store_migration(source_ref=str(tmp_path))
|
|
failed = runtime.apply_store_migration(source_ref=str(tmp_path))
|
|
|
|
assert planned["valid"] is False
|
|
assert planned["diagnostics"][0]["code"] == "corrupt_store_metadata"
|
|
assert failed["valid"] is False
|
|
assert failed["data"]["migration_result"]["applied"] is False
|
|
|
|
|
|
def test_repair_diagnostics_distinguish_corrupt_store_records(tmp_path) -> None:
|
|
store = FileBackedMemoryGraphStore(tmp_path)
|
|
runtime = PhaseMemoryRuntime(graph_store=store, event_log=JsonlMemoryEventLog(tmp_path / "events.jsonl"))
|
|
|
|
(tmp_path / "nodes" / "broken.json").write_text("{not-json}\n", encoding="utf-8")
|
|
|
|
envelope = runtime.repair_diagnostics(source_ref=str(tmp_path))
|
|
|
|
assert envelope["valid"] is False
|
|
assert envelope["diagnostics"][0]["code"] == "corrupt_store_record"
|
|
assert envelope["diagnostics"][0]["metadata"]["record_type"] == "node"
|
|
|
|
|
|
def test_lifecycle_apply_requires_approval_for_reviewable_actions(tmp_path) -> None:
|
|
store = FileBackedMemoryGraphStore(tmp_path)
|
|
runtime = PhaseMemoryRuntime(graph_store=store, event_log=JsonlMemoryEventLog(tmp_path / "events.jsonl"))
|
|
node = store.save_node(MemoryNode("node.a", "episode", "Trace text"))
|
|
compact = plan_compaction([node])
|
|
|
|
denied = runtime.apply_lifecycle_actions([compact])
|
|
|
|
assert denied["valid"] is False
|
|
assert denied["data"]["denied"][0]["reason"] == "review_required"
|
|
assert [node.node_id for node in store.list_nodes()] == ["node.a"]
|
|
|
|
applied = runtime.apply_lifecycle_actions([compact], approval_marker="review:local")
|
|
|
|
assert applied["valid"] is True
|
|
assert store.get_node(compact.target_id).kind == "summary"
|
|
|
|
|
|
def test_lifecycle_apply_can_mark_non_review_actions(tmp_path) -> None:
|
|
store = FileBackedMemoryGraphStore(tmp_path)
|
|
runtime = PhaseMemoryRuntime(graph_store=store, event_log=JsonlMemoryEventLog(tmp_path / "events.jsonl"))
|
|
store.save_node(MemoryNode("stale", "episode", freshness={"updated_at": "2026-05-01T00:00:00+00:00"}))
|
|
action = LifecycleAction(
|
|
LifecycleActionKind.MARK_STALE,
|
|
"stale",
|
|
from_state=LifecycleState.ACTIVE,
|
|
to_state=LifecycleState.STALE,
|
|
)
|
|
|
|
envelope = runtime.apply_lifecycle_actions([action])
|
|
|
|
assert envelope["valid"] is True
|
|
assert store.get_node("stale").lifecycle == LifecycleState.STALE
|