@michaelxwb/code-flow 0.6.5 → 0.8.1

package/src/core/code-flow/scripts/{cf_workflow_transaction.py → codeflow/spec/cf_workflow_transaction.py}

@@ -1,16 +1,17 @@
-"""Recoverable two-file workflow commits under the active-task lock."""
+"""Recoverable workflow commits under the active-task lock."""
 from __future__ import annotations
 
 import json
 from pathlib import Path
 from typing import Optional
 
-from cf_spec_context import _acquire_active_lock, _atomic_text, _release_active_lock
+from codeflow.core import cf_fs
+from codeflow.spec.cf_active_task import acquire_active_lock, release_active_lock
 
 
 def _read(path: Path) -> Optional[str]:
     try:
-        return path.read_text(encoding="utf-8")
+        return path.read_bytes().decode("utf-8")
     except FileNotFoundError:
         return None
 
@@ -21,7 +22,7 @@ def _write(path: Path, value: Optional[str]) -> None:
     if value is None:
         path.unlink()
     else:
-        _atomic_text(path, value)
+        cf_fs.atomic_write_text(path, value)
 
 
 def _journal_path(root: str) -> Path:
@@ -29,26 +30,34 @@ def _journal_path(root: str) -> Path:
 
 
 def _records(root: str, data: object) -> list[dict[str, object]]:
-    if not isinstance(data, dict) or data.get("version") != 1:
+    if not isinstance(data, dict) or data.get("version") not in (1, 2):
         raise ValueError("workflow recovery: invalid journal")
     rows = data.get("files")
-    if not isinstance(rows, list) or len(rows) != 2:
+    if not isinstance(rows, list) or len(rows) != (2 if data["version"] == 1 else 3):
         raise ValueError("workflow recovery: invalid files")
     base = Path(root).resolve()
     marker = base / ".code-flow/.active-task.json"
+    task_row = rows[-2]
+    if not isinstance(task_row, dict) or not isinstance(task_row.get("path"), str):
+        raise ValueError("workflow recovery: invalid task record")
+    task = Path(task_row["path"]).resolve()
+    context = task.parent / "spec-context.yml" if len(rows) == 3 else None
     for row in rows:
         if not isinstance(row, dict) or not isinstance(row.get("path"), str):
             raise ValueError("workflow recovery: invalid record")
         path = Path(row["path"]).resolve()
-        if base not in path.parents or (path != marker and path.suffix != ".md"):
+        if base not in path.parents or (path != marker and path != context and path.suffix != ".md"):
             raise ValueError("workflow recovery: out-of-scope path")
         for field in ("before", "after"):
             if field not in row or (row[field] is not None and not isinstance(row[field], str)):
                 raise ValueError("workflow recovery: invalid contents")
         if _read(path) not in (row["before"], row["after"]):
             raise ValueError(f"workflow recovery: concurrent change to {path}")
-    if Path(rows[1]["path"]).resolve() != marker or rows[0]["path"] == rows[1]["path"]:
+    if (task.suffix != ".md" or Path(rows[-1]["path"]).resolve() != marker
+            or len({str(Path(row["path"]).resolve()) for row in rows}) != len(rows)):
         raise ValueError("workflow recovery: marker must be last")
+    if context is not None and Path(rows[0]["path"]).resolve() != context:
+        raise ValueError("workflow recovery: invalid Context record")
     return rows
 
 
@@ -56,7 +65,7 @@ def recover_transition(root: str) -> bool:
     journal = _journal_path(root)
     if not journal.exists():
         return False
-    lock = _acquire_active_lock(root)
+    lock = acquire_active_lock(root)
     try:
         if not journal.exists():
             return False
@@ -66,23 +75,28 @@ def recover_transition(root: str) -> bool:
         journal.unlink()
         return True
     finally:
-        _release_active_lock(lock)
+        release_active_lock(lock)
 
 
 def commit_transition(root: str, task: Path, before: str, after: str,
-                      marker_before: Optional[str], marker_after: Optional[str]) -> None:
+                      marker_before: Optional[str], marker_after: Optional[str], *,
+                      context_change: Optional[tuple[Path, str, str]] = None) -> None:
     marker = Path(root).resolve() / ".code-flow/.active-task.json"
     rows = [{"path": str(task.resolve()), "before": before, "after": after},
             {"path": str(marker), "before": marker_before, "after": marker_after}]
+    if context_change is not None:
+        context, context_before, context_after = context_change
+        rows.insert(0, {"path": str(context.resolve()), "before": context_before, "after": context_after})
+    record = {"version": 2 if context_change is not None else 1, "files": rows}
     journal = _journal_path(root)
-    lock = _acquire_active_lock(root)
+    lock = acquire_active_lock(root)
     try:
         if journal.exists():
             raise ValueError("workflow recovery required before transition")
-        _records(root, {"version": 1, "files": rows})
+        _records(root, record)
         if any(_read(Path(row["path"])) != row["before"] for row in rows):
             raise ValueError("workflow concurrent change; retry transition")
-        _atomic_text(journal, json.dumps({"version": 1, "files": rows}, ensure_ascii=False))
+        cf_fs.atomic_write_text(journal, json.dumps(record, ensure_ascii=False))
         try:
             for row in rows:
                 _write(Path(row["path"]), row["after"])
@@ -93,4 +107,4 @@ def commit_transition(root: str, task: Path, before: str, after: str,
             raise
         journal.unlink()
     finally:
-        _release_active_lock(lock)
+        release_active_lock(lock)