@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/davinci-resolve-mcp/tests/test_destructive_decorator_coverage.py

@@ -1,92 +0,0 @@
-"""Enforce that every tool that owns destructive actions is decorated (C6).
-
-If you add a new entry to `DESTRUCTIVE_ACTIONS_BY_TOOL`, the corresponding
-top-level tool function in `src/server.py` must be decorated with
-`@_destructive_op("<tool_name>")` — otherwise the version-on-mutate hook never
-fires for that tool and edits go un-archived.
-
-This test does a static text scan of `server.py` (independent of FastMCP's
-runtime behavior) to guarantee the wiring.
-"""
-
-from __future__ import annotations
-
-import os
-import re
-import unittest
-
-from src.utils.destructive_hook import DESTRUCTIVE_ACTIONS_BY_TOOL
-
-SERVER_PATH = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-    "src", "server.py",
-)
-
-
-class DestructiveDecoratorCoverage(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls) -> None:
-        with open(SERVER_PATH, "r") as fh:
-            cls.source = fh.read()
-
-    def test_every_registered_tool_is_decorated(self) -> None:
-        missing: list[str] = []
-        for tool_name in sorted(DESTRUCTIVE_ACTIONS_BY_TOOL):
-            # Look for either order — @mcp.tool() before @_destructive_op or vice
-            # versa — followed by the def line.
-            pattern = re.compile(
-                rf"@_destructive_op\(\"{re.escape(tool_name)}\"\)\s*\n"
-                rf"def\s+{re.escape(tool_name)}\s*\(",
-                re.MULTILINE,
-            )
-            if not pattern.search(self.source):
-                missing.append(tool_name)
-        self.assertFalse(
-            missing,
-            msg=(
-                "These tools have destructive actions registered but are NOT "
-                "decorated with @_destructive_op in src/server.py: "
-                f"{missing}. Decorate them so the version-on-mutate hook fires."
-            ),
-        )
-
-    def test_decorator_pairs_with_mcp_tool(self) -> None:
-        """Every `@_destructive_op(X)` should sit between `@mcp.tool()` and `def X`."""
-        # Find every destructive_op decoration and its function name.
-        pattern = re.compile(
-            r"@mcp\.tool\(\)\s*\n@_destructive_op\(\"(?P<tool>[a-z_]+)\"\)\s*\ndef\s+(?P<fn>[a-z_]+)",
-            re.MULTILINE,
-        )
-        for match in pattern.finditer(self.source):
-            self.assertEqual(
-                match.group("tool"), match.group("fn"),
-                msg=(
-                    f"@_destructive_op(\"{match.group('tool')}\") sits above "
-                    f"def {match.group('fn')}(...) — the tool name and function "
-                    f"name must match."
-                ),
-            )
-
-    def test_destructive_op_only_on_registered_tools(self) -> None:
-        """Reject `@_destructive_op(X)` for X not in the registry."""
-        pattern = re.compile(
-            r"@_destructive_op\(\"(?P<tool>[a-z_]+)\"\)",
-            re.MULTILINE,
-        )
-        unregistered: list[str] = []
-        for match in pattern.finditer(self.source):
-            tool = match.group("tool")
-            if tool not in DESTRUCTIVE_ACTIONS_BY_TOOL:
-                unregistered.append(tool)
-        self.assertFalse(
-            unregistered,
-            msg=(
-                "These tools are decorated but have no entry in "
-                f"DESTRUCTIVE_ACTIONS_BY_TOOL: {unregistered}. Either add the "
-                "actions to the registry or remove the decorator."
-            ),
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_destructive_hook.py

@@ -1,245 +0,0 @@
-"""Unit tests for action-filtering and strict-mode behavior in destructive_hook.
-
-No Resolve required.
-"""
-
-from __future__ import annotations
-
-import unittest
-from unittest import mock
-
-from src.utils import destructive_hook
-
-
-class ActionFiltering(unittest.TestCase):
-    """is_destructive() consults both the registry AND the no-archive filter."""
-
-    def test_unregistered_action_is_not_destructive(self) -> None:
-        self.assertFalse(destructive_hook.is_destructive("timeline", "get_current"))
-
-    def test_registered_action_is_destructive_by_default(self) -> None:
-        self.assertTrue(destructive_hook.is_destructive("timeline", "delete_clips"))
-
-    def test_no_archive_filter_skips_notes_set_property(self) -> None:
-        # set_property with key=Notes shouldn't trigger versioning…
-        self.assertFalse(destructive_hook.is_destructive(
-            "timeline_item", "set_property", {"key": "Notes", "value": "free text"},
-        ))
-        # …but the same action with key=Name should.
-        self.assertTrue(destructive_hook.is_destructive(
-            "timeline_item", "set_property", {"key": "Name", "value": "renamed"},
-        ))
-
-    def test_no_archive_filter_only_applies_to_registered_keys(self) -> None:
-        # Comments isn't in the timeline_item filter set so it does archive.
-        self.assertTrue(destructive_hook.is_destructive(
-            "timeline_item", "set_property", {"key": "Comments", "value": "x"},
-        ))
-
-    def test_set_clip_property_on_timeline_filters_notes_and_comments(self) -> None:
-        for key in ("Notes", "Comments"):
-            self.assertFalse(
-                destructive_hook.is_destructive(
-                    "timeline", "set_clip_property", {"key": key, "value": "x"},
-                ),
-                msg=f"key={key} should be filtered out",
-            )
-
-    def test_missing_key_param_falls_through_to_archiving(self) -> None:
-        # set_property without key (malformed) should still archive — defaulting
-        # to safety, not silently skipping versioning.
-        self.assertTrue(destructive_hook.is_destructive(
-            "timeline_item", "set_property", {"value": "x"},
-        ))
-
-
-class StrictMode(unittest.TestCase):
-    """is_strict_required() flips on for catastrophic ops and explicit opt-in."""
-
-    def test_explicit_strict_param_wins(self) -> None:
-        self.assertTrue(destructive_hook.is_strict_required(
-            "timeline", "delete_clips", {"strict": True},
-        ))
-
-    def test_strict_default_actions(self) -> None:
-        self.assertTrue(destructive_hook.is_strict_required(
-            "timeline", "delete_track", None,
-        ))
-        # EX-REG: delete_timelines is a media_pool action now; it is archive +
-        # confirm-token gated (EX3) rather than strict.
-        self.assertFalse(destructive_hook.is_strict_required(
-            "timeline", "delete_timelines", None,
-        ))
-
-    def test_ripple_delete_is_strict(self) -> None:
-        self.assertTrue(destructive_hook.is_strict_required(
-            "timeline", "delete_clips", {"ripple": True, "clip_ids": ["a"]},
-        ))
-        # Non-ripple delete isn't strict by default.
-        self.assertFalse(destructive_hook.is_strict_required(
-            "timeline", "delete_clips", {"ripple": False, "clip_ids": ["a"]},
-        ))
-
-    def test_routine_action_is_not_strict(self) -> None:
-        self.assertFalse(destructive_hook.is_strict_required(
-            "timeline_item", "set_property", {"key": "Name", "value": "x"},
-        ))
-
-
-class WrapperWithProvider(unittest.TestCase):
-    """End-to-end: install a synthetic provider and verify the wrapper paths."""
-
-    def setUp(self) -> None:
-        self.saved_provider = destructive_hook._PROVIDER
-
-    def tearDown(self) -> None:
-        destructive_hook._PROVIDER = self.saved_provider
-
-    def test_strict_refuses_when_provider_returns_none(self) -> None:
-        destructive_hook.register_project_root_provider(lambda: None)
-
-        calls: list[str] = []
-
-        @destructive_hook.destructive_op("timeline")
-        def fake_timeline(action: str, params=None):
-            calls.append(action)
-            return {"success": True, "called_through": True}
-
-        # delete_track is strict-default; pass a confirm_token so the pending-confirm
-        # gate (delete_track is also token-gated) doesn't pre-empt the archive/strict
-        # path we're exercising here.
-        result = fake_timeline("delete_track", {"confirm_token": "x"})  # strict-default action
-        self.assertFalse(result["success"])
-        self.assertIn("strict mode", (result["error"].get("message","") if isinstance(result["error"], dict) else result["error"]))
-        self.assertEqual(calls, [], msg="underlying handler should NOT have been called")
-
-    def test_non_strict_runs_handler_when_provider_returns_none(self) -> None:
-        destructive_hook.register_project_root_provider(lambda: None)
-
-        calls: list[str] = []
-
-        @destructive_hook.destructive_op("timeline")
-        def fake_timeline(action: str, params=None):
-            calls.append(action)
-            return {"success": True, "called_through": True}
-
-        # A routine destructive op (not in STRICT_DEFAULT_ACTIONS) — should run.
-        result = fake_timeline("set_clip_color", {"clip_id": "x", "color": "Red"})
-        self.assertTrue(result["called_through"])
-        self.assertEqual(calls, ["set_clip_color"])
-
-    def test_filtered_payload_bypasses_versioning(self) -> None:
-        # Provider would raise if called — proves the filter short-circuits.
-        def failing_provider():
-            raise AssertionError("provider should not have been called")
-        destructive_hook.register_project_root_provider(failing_provider)
-
-        @destructive_hook.destructive_op("timeline_item")
-        def fake_ti(action: str, params=None):
-            return {"success": True, "wrote_notes": True}
-
-        result = fake_ti("set_property", {"key": "Notes", "value": "free text"})
-        self.assertTrue(result["wrote_notes"])
-
-
-class PendingConfirmCheckBypassesArchive(unittest.TestCase):
-    """F4 — when the underlying handler is about to issue a confirm_token (no
-    mutation), the wrapper must skip the archive entirely.
-    """
-
-    def setUp(self) -> None:
-        self.saved_provider = destructive_hook._PROVIDER
-        self.saved_check = destructive_hook._PENDING_CONFIRM_CHECK
-
-    def tearDown(self) -> None:
-        destructive_hook._PROVIDER = self.saved_provider
-        destructive_hook._PENDING_CONFIRM_CHECK = self.saved_check
-
-    def test_pending_check_skips_archive_and_brain_edit(self) -> None:
-        # Provider raises if called — proves the wrapper short-circuited
-        # before any archive/brain_edit path.
-        def failing_provider():
-            raise AssertionError("provider should not have been called")
-        destructive_hook.register_project_root_provider(failing_provider)
-        destructive_hook.register_pending_confirm_check(
-            lambda tool, action, params: action == "reset_all_grades"
-            and not (params or {}).get("confirm_token")
-        )
-
-        @destructive_hook.destructive_op("graph")
-        def fake_graph(action: str, params=None):
-            return {"error": {"code": "CONFIRMATION_REQUIRED",
-                              "category": "pending_user_decision"},
-                    "confirm_token": "abc123"}
-
-        result = fake_graph("reset_all_grades", {})
-        self.assertIn("confirm_token", result)
-        self.assertEqual(result["_versioning"]["archived"], False)
-        self.assertEqual(result["_versioning"]["skipped_reason"], "pending_confirm_token")
-
-    def test_pending_check_does_not_fire_when_token_present(self) -> None:
-        # When the consume call comes back with the token, archive must run.
-        called = {"provider": False}
-
-        def provider():
-            called["provider"] = True
-            return None  # non-strict path, OK to short-circuit after this.
-        destructive_hook.register_project_root_provider(provider)
-        destructive_hook.register_pending_confirm_check(
-            lambda tool, action, params: action == "reset_all_grades"
-            and not (params or {}).get("confirm_token")
-        )
-
-        @destructive_hook.destructive_op("graph")
-        def fake_graph(action: str, params=None):
-            return {"success": True}
-
-        result = fake_graph("reset_all_grades", {"confirm_token": "abc"})
-        self.assertTrue(result["success"])
-        self.assertTrue(called["provider"],
-                        "archive provider must run on the consume call")
-
-
-class AutoRunIdleTimeoutPreferenceTest(unittest.TestCase):
-    def setUp(self):
-        self._orig_pref_provider = destructive_hook._PREFERENCE_PROVIDER
-
-    def tearDown(self):
-        destructive_hook._PREFERENCE_PROVIDER = self._orig_pref_provider
-
-    def test_auto_run_honors_idle_timeout_preference(self):
-        destructive_hook.register_preference_provider(
-            lambda key: 45 if key == "versioning_auto_run_idle_timeout_seconds" else None
-        )
-        seen = {}
-
-        def fake_ensure(project_root, idle_timeout_seconds):
-            seen["timeout"] = idle_timeout_seconds
-            return "run-1"
-
-        with mock.patch.object(
-            destructive_hook.analysis_runs, "ensure_auto_run_for_destructive", fake_ensure
-        ):
-            run_id = destructive_hook._extract_analysis_run_id({}, project_root="/tmp/fake-root")
-
-        self.assertEqual(run_id, "run-1")
-        self.assertEqual(seen["timeout"], 45.0)
-
-    def test_auto_run_defaults_to_90s_without_preference(self):
-        destructive_hook._PREFERENCE_PROVIDER = None
-        seen = {}
-
-        def fake_ensure(project_root, idle_timeout_seconds):
-            seen["timeout"] = idle_timeout_seconds
-            return "run-2"
-
-        with mock.patch.object(
-            destructive_hook.analysis_runs, "ensure_auto_run_for_destructive", fake_ensure
-        ):
-            destructive_hook._extract_analysis_run_id({}, project_root="/tmp/fake-root")
-
-        self.assertEqual(seen["timeout"], 90.0)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_destructive_registry_drift.py

@@ -1,108 +0,0 @@
-"""Static guard: destructive-action registry strings must be REAL handlers.
-
-The EX2 bug: DESTRUCTIVE_ACTIONS_BY_TOOL["media_pool"] listed granular function
-names (delete_media_pool_clips, …) that the compound media_pool tool never
-dispatches, so is_destructive() returned False and catastrophic deletes silently
-skipped version-on-mutate archiving. This guard fails CI if any registry or
-token-gated action string is not an actual `action == "…"` branch in the tool
-function decorated with @_destructive_op("<tool>").
-"""
-from __future__ import annotations
-
-import ast
-import pathlib
-import unittest
-
-from src.utils.destructive_hook import DESTRUCTIVE_ACTIONS_BY_TOOL
-
-import src.server as s
-
-SERVER = pathlib.Path(__file__).resolve().parent.parent / "src" / "server.py"
-
-
-def _implemented_actions(fn):
-    """Actions a tool function handles: `action ==` branches plus the actions it
-    advertises in its _unknown(action, [...]) list (which includes actions it
-    dispatches via delegated helpers)."""
-    found = set()
-    for node in ast.walk(fn):
-        if isinstance(node, ast.Compare) and isinstance(node.left, ast.Name) and node.left.id == "action":
-            for comp in node.comparators:
-                if isinstance(comp, ast.Constant) and isinstance(comp.value, str):
-                    found.add(comp.value)
-                elif isinstance(comp, (ast.Set, ast.List, ast.Tuple)):
-                    found.update(
-                        elt.value for elt in comp.elts
-                        if isinstance(elt, ast.Constant) and isinstance(elt.value, str)
-                    )
-        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == "_unknown":
-            for arg in node.args:
-                if isinstance(arg, (ast.List, ast.Tuple)):
-                    found.update(
-                        elt.value for elt in arg.elts
-                        if isinstance(elt, ast.Constant) and isinstance(elt.value, str)
-                    )
-    return found
-
-
-def _destructive_op_tools():
-    """Map @_destructive_op("tool") -> set of implemented action strings."""
-    tree = ast.parse(SERVER.read_text())
-    out = {}
-    for node in ast.walk(tree):
-        if not isinstance(node, ast.FunctionDef):
-            continue
-        for dec in node.decorator_list:
-            if (
-                isinstance(dec, ast.Call)
-                and isinstance(dec.func, ast.Name)
-                and dec.func.id == "_destructive_op"
-                and dec.args
-                and isinstance(dec.args[0], ast.Constant)
-            ):
-                out[dec.args[0].value] = _implemented_actions(node)
-    return out
-
-
-class RegistryDriftTest(unittest.TestCase):
-    def setUp(self):
-        self.tools = _destructive_op_tools()
-        self.assertIn("media_pool", self.tools, "expected @_destructive_op('media_pool')")
-
-    def test_registry_actions_are_real_handlers(self):
-        # EX-REG: every registry action must be a real handler for its tool (impl
-        # `action ==` branch or advertised in the tool's _unknown list). Tools not
-        # wrapped with @_destructive_op have inert entries; none should remain.
-        for tool, actions in DESTRUCTIVE_ACTIONS_BY_TOOL.items():
-            impl = self.tools.get(tool)
-            self.assertIsNotNone(
-                impl, f"DESTRUCTIVE_ACTIONS_BY_TOOL has tool {tool!r} that is not @_destructive_op-wrapped"
-            )
-            for action in actions:
-                self.assertIn(
-                    action, impl,
-                    f"DESTRUCTIVE_ACTIONS_BY_TOOL[{tool!r}] lists {action!r}, but it is not a "
-                    f"real action of the {tool} tool (registry drift — governance would not fire).",
-                )
-
-    def test_token_gated_actions_are_real_handlers(self):
-        for tool, action in s._TOKEN_GATED_DESTRUCTIVE_ACTIONS:
-            impl = self.tools.get(tool)
-            if impl is None:
-                continue
-            self.assertIn(
-                action, impl,
-                f"_TOKEN_GATED_DESTRUCTIVE_ACTIONS has ({tool!r}, {action!r}) "
-                f"but it is not a real handler in the {tool} tool.",
-            )
-
-    def test_media_pool_catastrophic_deletes_registered_and_gated(self):
-        # Lock in EX2/EX3 specifically.
-        mp = DESTRUCTIVE_ACTIONS_BY_TOOL["media_pool"]
-        for action in ("delete_clips", "delete_folders", "delete_timelines"):
-            self.assertIn(action, mp)
-            self.assertIn(("media_pool", action), s._TOKEN_GATED_DESTRUCTIVE_ACTIONS)
-
-
-if __name__ == "__main__":
-    unittest.main()