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

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

@@ -1,292 +0,0 @@
-#!/usr/bin/env python3
-"""Live Extension Authoring boundary probe."""
-
-from __future__ import annotations
-
-import json
-import platform
-import shutil
-import sys
-import tempfile
-import time
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from src.utils.timeline_kernel_probe import ProbeRecorder, render_markdown_report, utc_timestamp
-
-
-def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
-    if not isinstance(result, dict):
-        raise AssertionError(f"{label}: expected dict, got {result!r}")
-    if result.get("error"):
-        raise AssertionError(f"{label}: {result['error']}")
-    if "success" in result and result["success"] is not True:
-        raise AssertionError(f"{label}: expected success=True, got {result!r}")
-    return result
-
-
-def _record_tool_result(
-    recorder: ProbeRecorder,
-    category: str,
-    name: str,
-    result: Dict[str, Any],
-    *,
-    expected_status: Optional[str] = None,
-) -> None:
-    if not isinstance(result, dict):
-        recorder.record(category, name, "error", details={"reason": "non-dict result", "result": repr(result)})
-        return
-    if result.get("error"):
-        recorder.record(category, name, expected_status or "error", details={"reason": result.get("error")}, evidence=result)
-        return
-    if "success" in result and result["success"] is not True:
-        recorder.record(
-            category,
-            name,
-            expected_status or "partially_supported",
-            details={"reason": "success returned false"},
-            evidence=result,
-        )
-        return
-    recorder.record(category, name, expected_status or "supported", evidence=result)
-
-
-def _record_nested_success(
-    recorder: ProbeRecorder,
-    category: str,
-    name: str,
-    result: Dict[str, Any],
-    keys: list[str],
-    *,
-    expected_status: Optional[str] = None,
-) -> None:
-    evidence: Dict[str, Any] = {}
-    failures = []
-    for key in keys:
-        value = result.get(key)
-        evidence[key] = value
-        if isinstance(value, dict):
-            if value.get("error"):
-                failures.append(f"{key}: {value['error']}")
-            elif "success" in value and value["success"] is not True:
-                failures.append(f"{key}: success returned false")
-        elif value is None:
-            failures.append(f"{key}: missing")
-    if failures:
-        recorder.record(category, name, expected_status or "partially_supported", details={"reason": "; ".join(failures)}, evidence=evidence)
-    else:
-        recorder.record(category, name, expected_status or "supported", evidence=evidence)
-
-
-def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, Any]:
-    output_dir.mkdir(parents=True, exist_ok=True)
-    work_dir = Path(tempfile.mkdtemp(prefix="mcp_extension_authoring_probe_"))
-    timestamp = int(time.time())
-    project_name = f"_mcp_extension_authoring_probe_{timestamp}"
-    recorder = ProbeRecorder()
-    cleanup_project = False
-    delete_result: Optional[Dict[str, Any]] = None
-
-    names = {
-        "fuse": f"_mcp_fuse_lifecycle_{timestamp}",
-        "dctl_lut": f"_mcp_dctl_lut_{timestamp}",
-        "dctl_aces": f"_mcp_dctl_aces_{timestamp}",
-        "script_py": f"_mcp_script_py_{timestamp}",
-        "script_lua": f"_mcp_script_lua_{timestamp}",
-    }
-
-    metadata: Dict[str, Any] = {
-        "title": "Extension Authoring Kernel Capability Probe",
-        "timestamp_utc": utc_timestamp(),
-        "python": sys.version,
-        "platform": platform.platform(),
-        "output_dir": str(output_dir),
-        "work_dir": str(work_dir),
-        "project_name": project_name,
-        "extension_names": names,
-    }
-
-    try:
-        version = _require_success("resolve_control.get_version", server.resolve_control("get_version"))
-        metadata.update(
-            {
-                "product": version.get("product"),
-                "version": version.get("version"),
-                "version_string": version.get("version_string"),
-            }
-        )
-        print(f"Connected to {metadata['product']} {metadata['version_string']}")
-
-        create = server.project_manager("safe_project_create", {"name": project_name})
-        _require_success("project_manager.safe_project_create", create)
-        cleanup_project = True
-        print(f"Created disposable project: {project_name}")
-
-        _record_tool_result(recorder, "project", "safe_project_create", create)
-        _record_tool_result(recorder, "capabilities", "extension_capabilities", server.script_plugin("extension_capabilities"))
-        for extension_type, category in [
-            ("fuse", None),
-            ("dctl", "lut"),
-            ("dctl", "aces_idt"),
-            ("dctl", "aces_odt"),
-            ("script", "Utility"),
-        ]:
-            params = {"extension_type": extension_type}
-            if category:
-                params["category"] = category
-            _record_tool_result(
-                recorder,
-                "lifecycle",
-                f"refresh_or_restart_required_{extension_type}_{category or 'default'}",
-                server.script_plugin("refresh_or_restart_required", params),
-            )
-
-        fuse_probe = server.script_plugin("probe_fuse_lifecycle", {
-            "name": names["fuse"],
-            "kind": "color_matrix",
-            "install": True,
-            "cleanup": True,
-            "overwrite": True,
-        })
-        _record_nested_success(recorder, "fuse", "probe_fuse_lifecycle_install_read_list_remove", fuse_probe, ["install", "read", "list", "remove"])
-
-        dctl_lut_probe = server.script_plugin("probe_dctl_lifecycle", {
-            "name": names["dctl_lut"],
-            "kind": "transform",
-            "category": "lut",
-            "subdir": "MCP",
-            "install": True,
-            "refresh_luts": True,
-            "cleanup": True,
-            "overwrite": True,
-        })
-        _record_nested_success(
-            recorder,
-            "dctl",
-            "probe_dctl_lut_lifecycle_install_refresh_remove",
-            dctl_lut_probe,
-            ["install", "read", "list", "refresh_luts", "remove"],
-        )
-
-        dctl_aces_probe = server.script_plugin("probe_dctl_lifecycle", {
-            "name": names["dctl_aces"],
-            "kind": "aces_idt",
-            "category": "aces_idt",
-            "subdir": "MCP",
-            "install": True,
-            "cleanup": True,
-            "overwrite": True,
-        })
-        _record_nested_success(
-            recorder,
-            "dctl",
-            "probe_dctl_aces_lifecycle_install_remove",
-            dctl_aces_probe,
-            ["install", "read", "list", "remove"],
-        )
-
-        script_py_probe = server.script_plugin("probe_script_lifecycle", {
-            "name": names["script_py"],
-            "kind": "scaffold",
-            "language": "py",
-            "category": "Utility",
-            "install": True,
-            "execute": True,
-            "cleanup": True,
-            "overwrite": True,
-            "timeout": 120,
-        })
-        _record_nested_success(
-            recorder,
-            "script",
-            "probe_script_python_lifecycle_install_execute_remove",
-            script_py_probe,
-            ["install", "read", "list", "execute", "remove"],
-        )
-
-        script_lua_probe = server.script_plugin("probe_script_lifecycle", {
-            "name": names["script_lua"],
-            "kind": "scaffold",
-            "language": "lua",
-            "category": "Utility",
-            "install": True,
-            "execute": True,
-            "cleanup": True,
-            "overwrite": True,
-            "timeout": 120,
-        })
-        _record_nested_success(
-            recorder,
-            "script",
-            "probe_script_lua_lifecycle_install_execute_remove",
-            script_lua_probe,
-            ["install", "read", "list", "execute", "remove"],
-        )
-
-        _record_tool_result(
-            recorder,
-            "script",
-            "run_inline_python_stdout",
-            server.script_plugin("run_inline", {"language": "py", "source": "print('extension inline py ok')", "timeout": 60}),
-        )
-        _record_tool_result(
-            recorder,
-            "script",
-            "run_inline_lua_stdout_result",
-            server.script_plugin("run_inline", {"language": "lua", "source": "print('extension inline lua ok')\nreturn 'lua-result'", "timeout": 60}),
-        )
-        _record_tool_result(
-            recorder,
-            "guards",
-            "safe_install_rejects_unmarked_source",
-            server.script_plugin("safe_install_extension", {
-                "extension_type": "script",
-                "name": f"_mcp_unmarked_{timestamp}",
-                "source": "print('missing marker')",
-                "language": "py",
-                "category": "Utility",
-                "dry_run": True,
-            }),
-            expected_status="unsupported",
-        )
-        _record_tool_result(
-            recorder,
-            "report",
-            "extension_boundary_report",
-            server.script_plugin("extension_boundary_report", {"include_template_matrix": True}),
-        )
-
-        if keep_open:
-            server.project_manager("save")
-            cleanup_project = False
-            print(f"LEFT PROJECT OPEN FOR INSPECTION: {project_name}")
-
-    finally:
-        if cleanup_project:
-            server.project_manager("save")
-            server.project_manager("close")
-            delete_result = server.project_manager("safe_project_delete", {"name": project_name})
-            print(f"Deleted disposable project: {delete_result}")
-
-    metadata["cleanup"] = {"project": delete_result}
-    report = recorder.to_report(
-        metadata,
-        {
-            "json": str(output_dir / "extension-authoring-probe.json"),
-            "markdown": str(output_dir / "extension-authoring-probe.md"),
-        },
-    )
-    json_path = output_dir / "extension-authoring-probe.json"
-    markdown_path = output_dir / "extension-authoring-probe.md"
-    json_path.write_text(json.dumps(report, indent=2, sort_keys=True), encoding="utf-8")
-    markdown_path.write_text(render_markdown_report(report), encoding="utf-8")
-    print(f"Wrote JSON report: {json_path}")
-    print(f"Wrote Markdown report: {markdown_path}")
-    print(f"Counts: {json.dumps(report['counts'], sort_keys=True)}")
-    if not keep_open:
-        shutil.rmtree(work_dir, ignore_errors=True)
-        print(f"Removed extension authoring work directory: {work_dir}")
-
-    if delete_result and delete_result.get("success") is not True:
-        raise AssertionError(f"Cleanup failed for {project_name}: {delete_result!r}")
-    return report

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

@@ -1,119 +0,0 @@
-"""E2 — session-scoped repeated-failure tracker for the structured error envelope.
-
-See local/design/agentic-flow-improvements-gameplan-2.md §3 task E2.
-
-The model should not be the only line of defense against tight retry loops.
-This module tracks per-(scope_key, action_name) failure counts in-process. When
-the same scope hits a configurable threshold within a rolling window, the
-caller can attach an `escalation` block to the next error response — a signal
-to stop auto-retrying and ask the user for guidance.
-
-Design choices:
-- In-process only. Session-scoped on purpose: a server restart drops state so
-  the agent's previous "grudge" doesn't leak across sessions.
-- Successes for the same key clear the counter (transient failures shouldn't
-  push the agent into escalation mode if the next attempt fixes things).
-- Window-based reset: if no failure for `window_seconds`, the counter resets.
-- scope_key is whatever the caller wants — typically a clip_id, a path, or
-  the literal "__no_scope__" sentinel when no clip/path context exists.
-"""
-from __future__ import annotations
-
-import threading
-import time
-from typing import Dict, List, Optional, Tuple
-
-# Tuple of (scope_key, action_name) -> list of failure timestamps (epoch seconds).
-_FAILURES: Dict[Tuple[str, str], List[float]] = {}
-_LOCK = threading.Lock()
-
-DEFAULT_THRESHOLD = 3
-DEFAULT_WINDOW_SECONDS = 600
-_NO_SCOPE = "__no_scope__"
-
-
-def _now() -> float:
-    return time.time()
-
-
-def _prune_outside_window(timestamps: List[float], now: float, window: float) -> List[float]:
-    cutoff = now - window
-    return [t for t in timestamps if t >= cutoff]
-
-
-def record_failure(scope_key: Optional[str], action_name: str,
-                   *, now: Optional[float] = None,
-                   window_seconds: int = DEFAULT_WINDOW_SECONDS) -> int:
-    """Record a failure for (scope_key, action_name). Returns the current
-    failure count within the rolling window after recording.
-    """
-    key = (scope_key or _NO_SCOPE, action_name)
-    when = now if now is not None else _now()
-    with _LOCK:
-        timestamps = _prune_outside_window(_FAILURES.get(key, []), when, window_seconds)
-        timestamps.append(when)
-        _FAILURES[key] = timestamps
-        return len(timestamps)
-
-
-def record_success(scope_key: Optional[str], action_name: str) -> None:
-    """A success on the same (scope_key, action_name) clears the failure counter."""
-    key = (scope_key or _NO_SCOPE, action_name)
-    with _LOCK:
-        _FAILURES.pop(key, None)
-
-
-def get_failure_state(scope_key: Optional[str], action_name: str,
-                      *, now: Optional[float] = None,
-                      window_seconds: int = DEFAULT_WINDOW_SECONDS) -> Dict[str, object]:
-    """Return current failure state for (scope_key, action_name) without mutating."""
-    key = (scope_key or _NO_SCOPE, action_name)
-    when = now if now is not None else _now()
-    with _LOCK:
-        timestamps = _prune_outside_window(_FAILURES.get(key, []), when, window_seconds)
-        if not timestamps:
-            return {"failure_count": 0,
-                    "first_failure_at": None,
-                    "last_failure_at": None}
-        return {"failure_count": len(timestamps),
-                "first_failure_at": _iso(timestamps[0]),
-                "last_failure_at": _iso(timestamps[-1])}
-
-
-def build_escalation_block(scope_key: Optional[str], action_name: str,
-                           error_category: str,
-                           *, threshold: int = DEFAULT_THRESHOLD,
-                           window_seconds: int = DEFAULT_WINDOW_SECONDS,
-                           now: Optional[float] = None) -> Optional[Dict[str, object]]:
-    """If failure count for (scope_key, action_name) is at/above threshold within
-    the rolling window, return an `escalation` dict to attach to the response.
-    Otherwise return None.
-
-    The dict is what the caller mounts as `response["escalation"] = ...`.
-    """
-    state = get_failure_state(scope_key, action_name,
-                              now=now, window_seconds=window_seconds)
-    if state["failure_count"] < threshold:
-        return None
-    return {
-        "recommended": True,
-        "reason": "repeated_failure",
-        "failure_count": state["failure_count"],
-        "first_failure_at": state["first_failure_at"],
-        "last_failure_at": state["last_failure_at"],
-        "suggested_action": (
-            f"Ask the user for guidance; do not auto-retry. "
-            f"The last {state['failure_count']} attempts on {action_name!r} "
-            f"for scope={scope_key or '(no scope)'} all returned {error_category!r}."
-        ),
-    }
-
-
-def reset_all() -> None:
-    """Clear all tracked failures. Tests + manual session reset only."""
-    with _LOCK:
-        _FAILURES.clear()
-
-
-def _iso(epoch_seconds: float) -> str:
-    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(epoch_seconds))