okstra 0.102.3 → 0.103.0

package/runtime/python/okstra_ctl/manager_sync.py

@@ -0,0 +1,144 @@
+"""Read project-local okstra state into manager-owned snapshots."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from okstra_project import TASKS_RELATIVE, parse_task_key, read_task_catalog, read_task_manifest, slugify
+
+from .manager_paths import children_json_path, projects_json_path, snapshots_json_path, task_manifest_path
+from .manager_store import _now_iso, _read_json, _read_json_default, _write_json
+
+
+def _project_map(home: Path, manager_id: str) -> dict[str, dict]:
+    projects = _read_json_default(projects_json_path(home, manager_id), {"projects": []})
+    return {
+        str(project.get("projectId")): project
+        for project in projects.get("projects", [])
+        if isinstance(project, dict) and project.get("projectId")
+    }
+
+
+def _phase_outcome(manifest: dict) -> dict:
+    value = manifest.get("phaseOutcome")
+    return value if isinstance(value, dict) else {}
+
+
+def _workflow(manifest: dict) -> dict:
+    value = manifest.get("workflow")
+    return value if isinstance(value, dict) else {}
+
+
+def _list_field(payload: dict, field: str) -> list:
+    value = payload.get(field)
+    return list(value) if isinstance(value, list) else []
+
+
+def _resolve_task_root_read_only(project_root: Path, task_key: str) -> Path | None:
+    _, task_group, task_id = parse_task_key(task_key)
+    requested_key = task_key.lower()
+    for entry in read_task_catalog(project_root):
+        entry_key = entry.get("taskKey") or ""
+        if not isinstance(entry_key, str) or entry_key.lower() != requested_key:
+            continue
+        relative_path = entry.get("taskRootPath") or entry.get("taskRoot") or ""
+        if not isinstance(relative_path, str) or not relative_path:
+            continue
+        candidate = project_root / relative_path if not Path(relative_path).is_absolute() else Path(relative_path)
+        if candidate.is_dir():
+            return candidate
+    slug_path = project_root / TASKS_RELATIVE / slugify(task_group) / slugify(task_id)
+    if slug_path.is_dir():
+        return slug_path
+    return None
+
+
+def _snapshot_child(project_root: Path, child: dict) -> dict:
+    task_key = str(child.get("taskKey") or "")
+    base = {
+        "projectId": str(child.get("projectId") or ""),
+        "taskGroup": str(child.get("taskGroup") or ""),
+        "taskId": str(child.get("taskId") or ""),
+        "taskKey": task_key,
+        "exists": False,
+        "taskRoot": "",
+    }
+    task_dir = _resolve_task_root_read_only(project_root, task_key)
+    if task_dir is None:
+        return base
+    manifest = read_task_manifest(task_dir) or {}
+    workflow = _workflow(manifest)
+    outcome = _phase_outcome(manifest)
+    return {
+        **base,
+        "exists": True,
+        "taskRoot": str(task_dir),
+        "taskType": str(manifest.get("taskType") or ""),
+        "currentPhase": str(workflow.get("currentPhase") or ""),
+        "currentPhaseState": str(workflow.get("currentPhaseState") or ""),
+        "lastCompletedPhase": str(workflow.get("lastCompletedPhase") or ""),
+        "nextRecommendedPhase": str(workflow.get("nextRecommendedPhase") or ""),
+        "latestRunStatus": str(manifest.get("latestRunStatus") or manifest.get("currentStatus") or ""),
+        "latestReportPath": str(manifest.get("latestReportPath") or ""),
+        "finalVerdict": str(outcome.get("finalVerdict") or ""),
+        "crossProjectDependencies": _list_field(outcome, "crossProjectDependencies"),
+        "recommendedNextSteps": _list_field(outcome, "recommendedNextSteps"),
+        "openClarifications": _list_field(outcome, "openClarifications"),
+    }
+
+
+def sync_task(home: Path, manager_id: str, task_group: str, task_id: str, *, now: str | None = None) -> dict:
+    _read_json(task_manifest_path(home, manager_id, task_group, task_id))
+    children = _read_json_default(children_json_path(home, manager_id, task_group, task_id), {"children": []})
+    projects = _project_map(home, manager_id)
+    rows = []
+    for child in children.get("children", []):
+        if not isinstance(child, dict):
+            continue
+        project = projects.get(str(child.get("projectId") or ""))
+        if project is None:
+            rows.append({**child, "exists": False, "error": "unknown project membership"})
+            continue
+        root = Path(str(project.get("projectRoot") or ""))
+        if not root.is_dir():
+            rows.append({**child, "exists": False, "error": f"missing project root: {root}"})
+            continue
+        rows.append(_snapshot_child(root, child))
+    payload = {
+        "managerId": manager_id,
+        "taskGroup": task_group,
+        "taskId": task_id,
+        "syncedAt": now or _now_iso(),
+        "children": rows,
+    }
+    _write_json(snapshots_json_path(home, manager_id, task_group, task_id), payload)
+    return payload
+
+
+def status_task(home: Path, manager_id: str, task_group: str, task_id: str) -> dict:
+    manifest = _read_json(task_manifest_path(home, manager_id, task_group, task_id))
+    children = _read_json_default(children_json_path(home, manager_id, task_group, task_id), {"children": []})
+    snapshot = _read_json_default(snapshots_json_path(home, manager_id, task_group, task_id), {"children": []})
+    by_key = {row.get("taskKey"): row for row in snapshot.get("children", []) if isinstance(row, dict)}
+    rows = []
+    summary = {"planned": 0, "missing": 0, "running": 0, "done": 0, "blocked": 0}
+    for child in children.get("children", []):
+        if not isinstance(child, dict):
+            continue
+        key = child.get("taskKey")
+        snapshot_row = by_key.get(key)
+        row = {**child, **(snapshot_row or {})}
+        status = str(row.get("latestRunStatus") or row.get("launch", {}).get("status") or "planned")
+        if snapshot_row is None:
+            summary["planned"] += 1
+        elif not row.get("exists", False):
+            summary["missing"] += 1
+        elif status == "done":
+            summary["done"] += 1
+        elif status in {"running", "started", "in-progress"}:
+            summary["running"] += 1
+        elif status == "blocked":
+            summary["blocked"] += 1
+        else:
+            summary["planned"] += 1
+        rows.append(row)
+    return {"manifest": manifest, "summary": summary, "children": rows, "lastSnapshot": snapshot}