@hybridlabor-api/aos 4.4.1 → 4.4.2-beta.0

package/mcps/davinci-resolve-mcp/src/utils/analysis_runs.py

@@ -1,307 +0,0 @@
-"""Run-scoping for the destructive-op hook (C6 hardening).
-
-A *run* groups a sequence of destructive operations under a single ID so that:
-
-1. **Archives collapse correctly.** Without run scoping, every destructive call
-   without an explicit `analysis_run_id` archives separately. A single brain
-   operation that touches five clips creates five archives. With run scoping,
-   the brain calls `begin_run` once, every subsequent destructive call within
-   that run reuses the same ID, and only the first one archives — the rest log
-   brain_edits under the same archived predecessor.
-2. **Cumulative metrics are computable.** `end_run` aggregates every brain_edit
-   for the run, captures a final timeline snapshot, and writes the rollup to
-   `analysis_runs.summary_json`. That's the row the dashboard reads to answer
-   "did this run improve the cut?"
-3. **Provenance is tracked.** Each run records its `initiator` (e.g.
-   "control_panel", "brain.chat", "agent.batch", "user.explicit"). The
-   `brain_edits.initiator` column is populated from the active run.
-
-Process-level state: a single `current_run_id` per process. The MCP server and
-the dashboard are separate processes, each with their own current run; that's
-intentional — a dashboard-initiated archive shouldn't get bundled into the
-brain's in-flight run.
-
-Threading: `_CURRENT_RUN` access is guarded by a lock, but a run is logically
-single-threaded. If two requests overlap with different `begin_run` calls,
-the second one's begin replaces the first — the first run remains in the DB
-but no longer accumulates edits. We could enforce stack-style nesting later if
-overlap becomes a real concern.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import threading
-import time
-import uuid
-from typing import Any, Dict, List, Optional
-
-from src.utils import timeline_brain_db
-
-logger = logging.getLogger("resolve-mcp.analysis-runs")
-
-_LOCK = threading.Lock()
-_CURRENT_RUN: Dict[str, Optional[str]] = {"id": None, "initiator": None, "label": None}
-
-# B3 — Auto-run idle tracking. Bumped on every destructive call within a run.
-_LAST_DESTRUCTIVE_AT: Dict[str, float] = {"epoch": 0.0}
-_DEFAULT_AUTO_RUN_IDLE_TIMEOUT_S = 90.0
-
-
-def _now_iso() -> str:
-    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-
-
-def _new_run_id() -> str:
-    return f"run_{uuid.uuid4().hex[:12]}"
-
-
-# ── Public API ───────────────────────────────────────────────────────────────
-
-
-def begin_run(
-    *,
-    project_root: str,
-    label: Optional[str] = None,
-    initiator: Optional[str] = None,
-    analysis_run_id: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Open a new run. Stamps `analysis_run_id` (or generates one) as the
-    process-level current run so the hook reads it automatically."""
-    run_id = analysis_run_id or _new_run_id()
-    started_at = _now_iso()
-    with timeline_brain_db.transaction(project_root) as txn:
-        txn.execute(
-            """
-            INSERT INTO analysis_runs(id, label, initiator, started_at)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(id) DO UPDATE SET
-                label = COALESCE(excluded.label, analysis_runs.label),
-                initiator = COALESCE(excluded.initiator, analysis_runs.initiator)
-            """,
-            (run_id, label, initiator, started_at),
-        )
-    with _LOCK:
-        # If an earlier run is still active, log a warning — the user probably
-        # forgot to end_run.
-        if _CURRENT_RUN["id"] and _CURRENT_RUN["id"] != run_id:
-            logger.warning(
-                "begin_run replacing previously-active run %s with %s (no end_run was called)",
-                _CURRENT_RUN["id"], run_id,
-            )
-        _CURRENT_RUN["id"] = run_id
-        _CURRENT_RUN["initiator"] = initiator
-        _CURRENT_RUN["label"] = label
-    return {
-        "success": True,
-        "analysis_run_id": run_id,
-        "label": label,
-        "initiator": initiator,
-        "started_at": started_at,
-    }
-
-
-def end_run(
-    *,
-    project_root: str,
-    analysis_run_id: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Close a run. Aggregates brain_edits + version count into `summary_json`."""
-    target_run_id: Optional[str] = analysis_run_id
-    with _LOCK:
-        active = _CURRENT_RUN["id"]
-        if target_run_id is None:
-            target_run_id = active
-        if active == target_run_id:
-            _CURRENT_RUN["id"] = None
-            _CURRENT_RUN["initiator"] = None
-            _CURRENT_RUN["label"] = None
-    if not target_run_id:
-        return {"success": False, "error": "no active run; pass analysis_run_id to end a specific run"}
-
-    conn = timeline_brain_db.connect(project_root)
-    edits = conn.execute(
-        """
-        SELECT edit_type, target_metric, before_value, after_value
-        FROM brain_edits WHERE analysis_run_id = ?
-        """,
-        (target_run_id,),
-    ).fetchall()
-    version_rows = conn.execute(
-        """
-        SELECT COUNT(*) AS c, MIN(version) AS min_v, MAX(version) AS max_v
-        FROM timeline_versions WHERE analysis_run_id = ?
-        """,
-        (target_run_id,),
-    ).fetchone()
-
-    summary = _summarise_run(list(edits), version_rows)
-    ended_at = _now_iso()
-    with timeline_brain_db.transaction(project_root) as txn:
-        txn.execute(
-            "UPDATE analysis_runs SET ended_at = ?, summary_json = ? WHERE id = ?",
-            (ended_at, json.dumps(summary), target_run_id),
-        )
-
-    return {
-        "success": True,
-        "analysis_run_id": target_run_id,
-        "ended_at": ended_at,
-        "summary": summary,
-    }
-
-
-def current_run_id() -> Optional[str]:
-    """Read the active process-level run ID. None if no run is open."""
-    with _LOCK:
-        return _CURRENT_RUN["id"]
-
-
-# ── B3 — Auto-run lifecycle ──────────────────────────────────────────────────
-
-
-def ensure_auto_run_for_destructive(
-    *,
-    project_root: str,
-    idle_timeout_seconds: Optional[float] = None,
-) -> str:
-    """Return the analysis_run_id to use for a destructive op.
-
-    Behavior:
-    - If a run is already active and within the idle timeout: reuse it, bump idle timer.
-    - If a run is active but idle timer expired: end_run it, open a fresh auto-run.
-    - If no run is active: open a fresh auto-run with initiator="auto".
-
-    The caller (destructive_hook) plumbs the returned run_id through the
-    rest of its bookkeeping just as it would an explicit begin_run id.
-    """
-    timeout = float(idle_timeout_seconds if idle_timeout_seconds is not None else _DEFAULT_AUTO_RUN_IDLE_TIMEOUT_S)
-    now = time.time()
-    with _LOCK:
-        active = _CURRENT_RUN["id"]
-        last = _LAST_DESTRUCTIVE_AT["epoch"]
-        if active and last and (now - last) > timeout:
-            # idle timeout — auto-close before opening fresh
-            stale_id = active
-            _CURRENT_RUN["id"] = None
-            _CURRENT_RUN["initiator"] = None
-            _CURRENT_RUN["label"] = None
-        else:
-            stale_id = None
-
-    if stale_id:
-        try:
-            end_run(project_root=project_root, analysis_run_id=stale_id)
-        except Exception as exc:  # never block the destructive call on close failure
-            logger.warning("auto end_run for %s failed: %s", stale_id, exc)
-
-    with _LOCK:
-        if _CURRENT_RUN["id"]:
-            _LAST_DESTRUCTIVE_AT["epoch"] = now
-            return str(_CURRENT_RUN["id"])
-
-    # Open a fresh auto-run.
-    result = begin_run(project_root=project_root, label=f"auto-{_now_iso()}", initiator="auto")
-    with _LOCK:
-        _LAST_DESTRUCTIVE_AT["epoch"] = now
-    return str(result["analysis_run_id"])
-
-
-def bump_idle_timer() -> None:
-    """Called by destructive_hook on every wrap entry within an active run."""
-    with _LOCK:
-        _LAST_DESTRUCTIVE_AT["epoch"] = time.time()
-
-
-def current_run_initiator() -> Optional[str]:
-    with _LOCK:
-        return _CURRENT_RUN["initiator"]
-
-
-def get_run(project_root: str, analysis_run_id: str) -> Optional[Dict[str, Any]]:
-    conn = timeline_brain_db.connect(project_root)
-    row = conn.execute(
-        "SELECT id, label, initiator, started_at, ended_at, summary_json FROM analysis_runs WHERE id = ?",
-        (analysis_run_id,),
-    ).fetchone()
-    if row is None:
-        return None
-    out = dict(row)
-    raw = out.pop("summary_json")
-    out["summary"] = json.loads(raw) if raw else None
-    return out
-
-
-def list_runs(project_root: str, *, limit: int = 50) -> List[Dict[str, Any]]:
-    # SQLite treats a negative LIMIT as "no limit"; clamp (EX8).
-    try:
-        limit = max(1, min(1000, int(limit)))
-    except (TypeError, ValueError):
-        limit = 50
-    conn = timeline_brain_db.connect(project_root)
-    rows = conn.execute(
-        """
-        SELECT id, label, initiator, started_at, ended_at, summary_json
-        FROM analysis_runs
-        ORDER BY started_at DESC
-        LIMIT ?
-        """,
-        (int(limit),),
-    ).fetchall()
-    out: List[Dict[str, Any]] = []
-    for r in rows:
-        d = dict(r)
-        raw = d.pop("summary_json")
-        d["summary"] = json.loads(raw) if raw else None
-        out.append(d)
-    return out
-
-
-# ── Test hooks ───────────────────────────────────────────────────────────────
-
-
-def _reset_for_test() -> None:
-    """Tests only: clear the process-level current run."""
-    with _LOCK:
-        _CURRENT_RUN["id"] = None
-        _CURRENT_RUN["initiator"] = None
-        _CURRENT_RUN["label"] = None
-        _LAST_DESTRUCTIVE_AT["epoch"] = 0.0
-
-
-# ── Helpers ──────────────────────────────────────────────────────────────────
-
-
-def _summarise_run(edits: List[Any], version_row: Any) -> Dict[str, Any]:
-    """Aggregate brain_edits into a per-metric rollup."""
-    per_metric: Dict[str, Dict[str, Any]] = {}
-    for edit in edits:
-        metric = edit["target_metric"] if isinstance(edit, dict) or hasattr(edit, "__getitem__") else None
-        try:
-            metric = edit["target_metric"]
-            before = edit["before_value"]
-            after = edit["after_value"]
-        except (KeyError, IndexError, TypeError):
-            continue
-        if not metric:
-            continue
-        bucket = per_metric.setdefault(metric, {"edit_count": 0, "first_before": None, "last_after": None, "total_delta": 0.0})
-        bucket["edit_count"] += 1
-        if before is not None and bucket["first_before"] is None:
-            bucket["first_before"] = float(before)
-        if after is not None:
-            bucket["last_after"] = float(after)
-        if before is not None and after is not None:
-            try:
-                bucket["total_delta"] = round(bucket["total_delta"] + (float(after) - float(before)), 6)
-            except (TypeError, ValueError):
-                pass
-
-    return {
-        "edit_count": len(edits),
-        "version_count": int(version_row["c"]) if version_row and version_row["c"] is not None else 0,
-        "first_version": (int(version_row["min_v"]) if version_row and version_row["min_v"] is not None else None),
-        "last_version": (int(version_row["max_v"]) if version_row and version_row["max_v"] is not None else None),
-        "per_metric": per_metric,
-    }