@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,116 +0,0 @@
-"""Contract tests for C2 — propose_grade structured output action.
-
-See local/design/agentic-flow-improvements-gameplan.md §3 task C2.
-"""
-import unittest
-
-import src.server as compound
-
-
-GOOD_EVIDENCE = "evidence base: hero shot 2A graded (Version 1, 3 nodes)"
-
-
-class ProposeGradeValidationTest(unittest.TestCase):
-    def test_missing_target_id(self):
-        err = compound._propose_grade_validate({
-            "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/a.jpg"],
-            "operation_class": "review_only",
-        })
-        self.assertEqual(err["error"]["code"], "MISSING_TARGET_ID")
-
-    def test_missing_evidence_base(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "frame_paths": ["/a.jpg"], "operation_class": "review_only",
-        })
-        self.assertEqual(err["error"]["code"], "MISSING_EVIDENCE_BASE")
-
-    def test_evidence_base_must_start_with_canonical_prefix(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "evidence_base": "some other prefix",
-            "frame_paths": ["/a.jpg"], "operation_class": "review_only",
-        })
-        self.assertEqual(err["error"]["code"], "EVIDENCE_BASE_MALFORMED")
-
-    def test_missing_frame_paths(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "operation_class": "direct",
-        })
-        self.assertEqual(err["error"]["code"], "MISSING_FRAME_PATHS")
-
-    def test_invalid_operation_class(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/a.jpg"], "operation_class": "garbage",
-        })
-        self.assertEqual(err["error"]["code"], "INVALID_OPERATION_CLASS")
-
-    def test_direct_requires_cdl(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/a.jpg"], "operation_class": "direct",
-            "cdl_delta_or_artifact": {},
-        })
-        self.assertEqual(err["error"]["code"], "DIRECT_REQUIRES_CDL")
-
-    def test_opaque_requires_artifact(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/a.jpg"], "operation_class": "opaque",
-            "cdl_delta_or_artifact": {},
-        })
-        self.assertEqual(err["error"]["code"], "OPAQUE_REQUIRES_ARTIFACT")
-
-    def test_asset_requires_lut_path(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/a.jpg"], "operation_class": "asset",
-            "cdl_delta_or_artifact": {},
-        })
-        self.assertEqual(err["error"]["code"], "ASSET_REQUIRES_LUT_PATH")
-
-    def test_review_only_requires_two_frames(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/only_one.jpg"], "operation_class": "review_only",
-        })
-        self.assertEqual(err["error"]["code"], "REVIEW_NEEDS_FRAMES")
-
-    def test_unsupported_requires_explanation(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/a.jpg"], "operation_class": "unsupported",
-        })
-        self.assertEqual(err["error"]["code"], "UNSUPPORTED_NEEDS_EXPLANATION")
-
-    def test_valid_review_only(self):
-        err = compound._propose_grade_validate({
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/a.jpg", "/b.jpg"], "operation_class": "review_only",
-        })
-        self.assertIsNone(err)
-
-
-class ProposeGradeExecuteTest(unittest.TestCase):
-    def test_default_does_not_execute(self):
-        out = compound._propose_grade(None, {
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/a.jpg", "/b.jpg"], "operation_class": "review_only",
-        })
-        self.assertTrue(out["accepted"])
-        self.assertFalse(out["executed"])
-        self.assertTrue(out["plan_id"].startswith("plan_"))
-
-    def test_execute_review_only_is_noop(self):
-        out = compound._propose_grade(None, {
-            "target_id": "x", "evidence_base": GOOD_EVIDENCE,
-            "frame_paths": ["/a.jpg", "/b.jpg"],
-            "operation_class": "review_only", "execute": True,
-        })
-        self.assertFalse(out["executed"])
-        self.assertIn("notes", out["validation"])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,88 +0,0 @@
-"""F1 contract test — aggregated provenance citation map on summarize.
-
-See local/design/agentic-flow-improvements-gameplan-2.md §3 task F1.
-
-Exercises `summarize_reports` against a tmpdir that mimics the analysis-root
-layout (clips/<dir>/analysis.json files). Asserts the response carries a
-`provenance` block with source_reports keyed by signature and a generated_at
-timestamp.
-"""
-import json
-import os
-import tempfile
-import unittest
-
-from src.utils.media_analysis import summarize_reports
-
-
-def _write_report(clip_dir: str, *, signature: str = None, clip_id: str = "c-1",
-                  clip_name: str = "clip.mp4") -> str:
-    os.makedirs(clip_dir, exist_ok=True)
-    path = os.path.join(clip_dir, "analysis.json")
-    body = {
-        "clip_id": clip_id,
-        "clip_name": clip_name,
-        "analysis_signature": signature,
-        "analyzed_at": "2026-05-27T22:00:00Z",
-        "record": {"clip_id": clip_id, "clip_name": clip_name},
-        "technical": {"width": 1920, "height": 1080},
-        "motion": {"overall_motion_level": "medium"},
-        "visual": {"editing_notes": {"search_tags": ["interview", "close-up"]}},
-    }
-    with open(path, "w", encoding="utf-8") as fh:
-        json.dump(body, fh)
-    return path
-
-
-class ProvenanceCitationMapTest(unittest.TestCase):
-    def test_summarize_emits_provenance_block(self):
-        with tempfile.TemporaryDirectory() as project_root:
-            clips_root = os.path.join(project_root, "clips")
-            _write_report(os.path.join(clips_root, "clip-a"),
-                          signature="sig-aaa", clip_id="c-a", clip_name="A.mp4")
-            _write_report(os.path.join(clips_root, "clip-b"),
-                          signature="sig-bbb", clip_id="c-b", clip_name="B.mp4")
-            out = summarize_reports(project_root)
-        self.assertIn("provenance", out)
-        prov = out["provenance"]
-        self.assertIn("generated_at", prov)
-        self.assertEqual(prov["scope"]["type"], "project")
-        self.assertEqual(len(prov["source_reports"]), 2)
-
-    def test_source_reports_carry_signature_and_path(self):
-        with tempfile.TemporaryDirectory() as project_root:
-            clips_root = os.path.join(project_root, "clips")
-            _write_report(os.path.join(clips_root, "clip-a"),
-                          signature="sig-aaa", clip_id="c-a", clip_name="A.mp4")
-            out = summarize_reports(project_root)
-        entry = out["provenance"]["source_reports"][0]
-        self.assertEqual(entry["clip_id"], "c-a")
-        self.assertEqual(entry["clip_name"], "A.mp4")
-        self.assertEqual(entry["analysis_signature"], "sig-aaa")
-        self.assertTrue(entry["analysis_report_path"].endswith("analysis.json"))
-        self.assertEqual(entry["analyzed_at"], "2026-05-27T22:00:00Z")
-
-    def test_unsigned_report_shows_up_in_missing_reports(self):
-        with tempfile.TemporaryDirectory() as project_root:
-            clips_root = os.path.join(project_root, "clips")
-            _write_report(os.path.join(clips_root, "clip-a"),
-                          signature=None, clip_id="c-a")  # unsigned
-            _write_report(os.path.join(clips_root, "clip-b"),
-                          signature="sig-bbb", clip_id="c-b")
-            out = summarize_reports(project_root)
-        # Both reports still surface in source_reports (the citation map is
-        # exhaustive), but the unsigned one is flagged in missing_reports.
-        self.assertEqual(len(out["provenance"]["source_reports"]), 2)
-        missing = out["provenance"]["missing_reports"]
-        self.assertEqual(len(missing), 1)
-        self.assertEqual(missing[0]["reason"], "unsigned_report")
-
-    def test_empty_project_returns_empty_provenance(self):
-        with tempfile.TemporaryDirectory() as project_root:
-            out = summarize_reports(project_root)
-        self.assertEqual(out["provenance"]["source_reports"], [])
-        self.assertEqual(out["provenance"]["missing_reports"], [])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,77 +0,0 @@
-"""Tests for the verify_by_readback verification primitive."""
-import unittest
-
-from src.utils.readback import verify_by_readback
-
-
-class VerifyByReadbackTest(unittest.TestCase):
-    def test_default_verified_is_truthy_observed(self):
-        out = verify_by_readback(mutate=lambda: True, observe=lambda: "linked")
-        self.assertTrue(out["success_raw"])
-        self.assertTrue(out["verified"])
-        self.assertFalse(out["contradiction"])
-
-    def test_default_verified_false_on_empty_observe(self):
-        out = verify_by_readback(mutate=lambda: True, observe=lambda: "")
-        self.assertTrue(out["success_raw"])
-        self.assertFalse(out["verified"])
-
-    def test_contradiction_flagged(self):
-        # API lies: reports success but the readback shows nothing happened.
-        out = verify_by_readback(
-            mutate=lambda: True, observe=lambda: None, label="lying_op"
-        )
-        self.assertTrue(out["success_raw"])
-        self.assertFalse(out["verified"])
-        self.assertTrue(out["contradiction"])
-
-    def test_no_contradiction_when_both_false(self):
-        out = verify_by_readback(mutate=lambda: False, observe=lambda: None)
-        self.assertFalse(out["success_raw"])
-        self.assertFalse(out["verified"])
-        self.assertFalse(out["contradiction"])
-
-    def test_snapshot_passed_to_compare_as_before(self):
-        seen = {}
-
-        def cmp(before, observed):
-            seen["before"] = before
-            seen["observed"] = observed
-            return {"verified": observed > before}
-
-        out = verify_by_readback(
-            mutate=lambda: True,
-            observe=lambda: 10,
-            snapshot=lambda: 3,
-            compare=cmp,
-        )
-        self.assertEqual(seen["before"], 3)
-        self.assertEqual(seen["observed"], 10)
-        self.assertTrue(out["verified"])
-
-    def test_compare_fields_merged(self):
-        out = verify_by_readback(
-            mutate=lambda: True,
-            observe=lambda: ["a"],
-            compare=lambda before, obs: {"verified": True, "linked": obs},
-        )
-        self.assertEqual(out["linked"], ["a"])
-
-    def test_intent_included(self):
-        out = verify_by_readback(
-            mutate=lambda: True, observe=lambda: 1, intent={"k": "v"}
-        )
-        self.assertEqual(out["intent"], {"k": "v"})
-
-    def test_mutate_runs_before_observe(self):
-        order = []
-        verify_by_readback(
-            mutate=lambda: order.append("mutate"),
-            observe=lambda: order.append("observe") or True,
-            snapshot=lambda: order.append("snapshot"),
-        )
-        self.assertEqual(order, ["snapshot", "mutate", "observe"])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,43 +0,0 @@
-"""Tests for the read/write symmetry audit logic."""
-import importlib.util
-import os
-import unittest
-
-_SPEC = importlib.util.spec_from_file_location(
-    "audit_rw",
-    os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-                 "scripts", "audit_readwrite_symmetry.py"),
-)
-audit_rw = importlib.util.module_from_spec(_SPEC)
-_SPEC.loader.exec_module(audit_rw)
-
-
-class AuditTest(unittest.TestCase):
-    def test_set_without_get_is_high_signal(self):
-        src = 'return _unknown(action, ["get_name","set_name","set_orphan"])'
-        total, covered, high, low = audit_rw.audit(src)
-        self.assertIn("set_orphan", high)
-        self.assertNotIn("set_name", high)  # get_name covers it
-
-    def test_plural_read_counts_as_covered(self):
-        src = 'return _unknown(action, ["add_keyframe","get_keyframes"])'
-        _, covered, high, low = audit_rw.audit(src)
-        self.assertEqual(high, [])
-        self.assertEqual(low, [])  # add_keyframe covered by plural get_keyframes
-        self.assertEqual(covered, 1)
-
-    def test_create_is_low_signal(self):
-        src = 'return _unknown(action, ["create_timeline"])'
-        _, _, high, low = audit_rw.audit(src)
-        self.assertEqual(high, [])
-        self.assertIn("create_timeline", low)
-
-    def test_enabled_variant_covered(self):
-        # set_track_enable should be covered by get_track_enabled (stem rstrip).
-        src = 'return _unknown(action, ["set_track_enabled","get_track_enabled"])'
-        _, _, high, _low = audit_rw.audit(src)
-        self.assertEqual(high, [])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,149 +0,0 @@
-"""Issue #77 — 'Reel Name' writes return True but are silently dropped.
-
-Resolve accepts SetClipProperty('Reel Name', ...) / SetMetadata('Reel Name', ...)
-and returns True, but when the project derives reel names automatically the value
-never persists. We read it back and refuse to report success on mismatch. These
-tests exercise the verifier helpers directly and through the media_pool_item
-dispatcher with a fake clip whose 'Reel Name' write is a no-op.
-"""
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class FakeClip:
-    """A clip whose 'Reel Name' write silently no-ops (matches issue #77),
-    while every other property writes and persists normally."""
-
-    def __init__(self, drop_keys=("Reel Name",)):
-        self.props = {}
-        self.meta = {}
-        self.drop_keys = set(drop_keys)
-
-    def GetUniqueId(self):
-        return "clip-1"
-
-    def GetName(self):
-        return "17001_C006.mov"
-
-    # Clip properties -----------------------------------------------------
-    def SetClipProperty(self, key, value):
-        if key not in self.drop_keys:
-            self.props[key] = value
-        return True  # Resolve lies: True even for the dropped key
-
-    def GetClipProperty(self, key=""):
-        if key == "":
-            return dict(self.props)
-        return self.props.get(key, "")
-
-    # Metadata ------------------------------------------------------------
-    def SetMetadata(self, key_or_dict, value=None):
-        items = key_or_dict.items() if isinstance(key_or_dict, dict) else [(key_or_dict, value)]
-        for k, v in items:
-            # 'Reel Name' is really a clip property; SetMetadata accepts it but
-            # it lands nowhere observable (drop), like the live bug.
-            if k not in self.drop_keys:
-                self.meta[k] = v
-        return True
-
-
-class VerifierHelpers(unittest.TestCase):
-    def test_persisted_write_returns_none(self):
-        clip = FakeClip(drop_keys=())  # nothing dropped
-        clip.SetClipProperty("Reel Name", "TOPDOWN-C006")
-        self.assertIsNone(
-            s._verify_clip_property_writeback(clip, "Reel Name", "TOPDOWN-C006")
-        )
-
-    def test_silent_revert_returns_failure(self):
-        clip = FakeClip()
-        clip.SetClipProperty("Reel Name", "TOPDOWN-C006")  # dropped
-        fail = s._verify_clip_property_writeback(clip, "Reel Name", "TOPDOWN-C006")
-        self.assertIsNotNone(fail)
-        self.assertFalse(fail["success"])
-        self.assertFalse(fail["verified"])
-        self.assertEqual(fail["requested"], "TOPDOWN-C006")
-        self.assertEqual(fail["actual"], "")
-        self.assertIn("did not", fail["error"].lower())
-        self.assertIn("Assist using reel names", fail["hint"])
-
-    def test_unwatched_key_is_never_verified(self):
-        clip = FakeClip(drop_keys=("Comments",))  # Comments dropped but unwatched
-        self.assertIsNone(
-            s._verify_clip_property_writeback(clip, "Comments", "hello")
-        )
-
-    def test_unreadable_does_not_contradict(self):
-        clip = FakeClip()
-        # GetClipProperty raises -> we can't read back -> don't override success
-        with mock.patch.object(clip, "GetClipProperty", side_effect=RuntimeError):
-            self.assertIsNone(
-                s._verify_clip_property_writeback(clip, "Reel Name", "X")
-            )
-
-    def test_verify_writeback_batch_finds_dropped_key(self):
-        clip = FakeClip()
-        fail = s._verify_writeback(clip, {"Comments": "ok", "Reel Name": "X"})
-        self.assertIsNotNone(fail)
-        self.assertEqual(fail["key"], "Reel Name")
-
-
-class DispatcherIntegration(unittest.TestCase):
-    def _run(self, action, params, clip):
-        fake_mp = mock.Mock()
-        with mock.patch.object(s, "_get_mp", return_value=(None, None, fake_mp, None)), \
-             mock.patch.object(s, "_find_clip", return_value=clip):
-            return s.media_pool_item(action, params)
-
-    def test_set_clip_property_reel_name_reports_failure(self):
-        clip = FakeClip()
-        res = self._run("set_clip_property",
-                        {"clip_id": "clip-1", "key": "Reel Name", "value": "TOPDOWN-C006"},
-                        clip)
-        self.assertFalse(res["success"])
-        self.assertFalse(res["verified"])
-        self.assertIn("hint", res)
-
-    def test_set_clip_property_normal_field_still_succeeds(self):
-        clip = FakeClip()
-        res = self._run("set_clip_property",
-                        {"clip_id": "clip-1", "key": "Comments", "value": "hi"},
-                        clip)
-        self.assertTrue(res["success"])
-        self.assertNotIn("verified", res)
-
-    def test_set_metadata_dict_form_reel_name_fails(self):
-        clip = FakeClip()
-        res = self._run("set_metadata",
-                        {"clip_id": "clip-1", "metadata": {"Reel Name": "FRONT-C003"}},
-                        clip)
-        self.assertFalse(res["success"])
-        self.assertFalse(res["verified"])
-
-    def test_set_metadata_keyvalue_form_reel_name_fails(self):
-        clip = FakeClip()
-        res = self._run("set_metadata",
-                        {"clip_id": "clip-1", "key": "Reel Name", "value": "FRONT-C004"},
-                        clip)
-        self.assertFalse(res["success"])
-
-    def test_normalize_metadata_marks_unpersisted(self):
-        clip = FakeClip()
-        fake_root = object()
-        fake_mp = mock.Mock()
-        fake_mp.GetRootFolder.return_value = fake_root
-        with mock.patch.object(s, "_clips_from_params", return_value=(([clip], []), None)):
-            res = s._normalize_metadata(None, fake_mp, {
-                "clip_ids": ["clip-1"],
-                "metadata": {"Reel Name": "TOPDOWN-C001"},
-            })
-        self.assertFalse(res["success"])
-        row = res["results"][0]
-        self.assertFalse(row["success"])
-        self.assertEqual(row["unpersisted"], {"Reel Name": ""})
-
-
-if __name__ == "__main__":
-    unittest.main()