@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,253 +0,0 @@
-"""Tests for the headless batch-runner CLI (src/batch_cli.py).
-
-These cover argparse plumbing and exit-code mapping. Engine-level behavior
-(slice execution, index building, cancel/resume) is already covered by
-tests/test_media_analysis.py — we trust it here.
-"""
-from __future__ import annotations
-
-import io
-import json
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-import unittest
-from contextlib import redirect_stdout
-from unittest.mock import patch
-
-from src import batch_cli
-from src.utils import media_analysis_jobs
-
-
-class BatchCliParserTests(unittest.TestCase):
-    def test_help_lists_all_subcommands(self):
-        parser = batch_cli._build_parser()
-        # SystemExit on --help is expected; capture and inspect text.
-        with self.assertRaises(SystemExit):
-            with redirect_stdout(io.StringIO()) as buf:
-                parser.parse_args(["--help"])
-        text = buf.getvalue()
-        for sub in ("plan", "run", "status", "list", "resume", "cancel"):
-            self.assertIn(sub, text)
-
-    def test_run_requires_paths(self):
-        parser = batch_cli._build_parser()
-        with self.assertRaises(SystemExit):
-            with redirect_stdout(io.StringIO()), patch("sys.stderr", io.StringIO()):
-                parser.parse_args(["run"])
-
-    def test_run_rejects_invalid_depth(self):
-        parser = batch_cli._build_parser()
-        with self.assertRaises(SystemExit):
-            with redirect_stdout(io.StringIO()), patch("sys.stderr", io.StringIO()):
-                parser.parse_args(["run", "/tmp/x", "--depth", "bogus"])
-
-    def test_json_flag_works_in_either_position(self):
-        parser = batch_cli._build_parser()
-        before = parser.parse_args(["--json", "run", "/tmp/x"])
-        after = parser.parse_args(["run", "/tmp/x", "--json"])
-        self.assertTrue(before.json)
-        self.assertTrue(after.json)
-
-    def test_run_defaults(self):
-        parser = batch_cli._build_parser()
-        args = parser.parse_args(["run", "/tmp/x"])
-        self.assertEqual(args.cmd, "run")
-        self.assertTrue(args.recursive)
-        self.assertEqual(args.max_clips, 1)
-        self.assertIsNone(args.max_seconds)
-        self.assertFalse(args.no_follow)
-        self.assertIsNone(args.depth)
-        # --json uses SUPPRESS so absence means default-false (applied in main()).
-        self.assertFalse(hasattr(args, "json"))
-
-
-class BatchCliExitCodeTests(unittest.TestCase):
-    def test_plan_with_no_media_returns_fatal(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            empty_dir = os.path.join(tmp, "empty")
-            os.makedirs(empty_dir)
-            with redirect_stdout(io.StringIO()):
-                rc = batch_cli.main(["plan", empty_dir])
-        self.assertEqual(rc, batch_cli.EXIT_FATAL)
-
-    def test_run_with_no_media_returns_fatal_and_emits_json(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            empty_dir = os.path.join(tmp, "empty")
-            os.makedirs(empty_dir)
-            buf = io.StringIO()
-            with redirect_stdout(buf):
-                rc = batch_cli.main(["--json", "run", empty_dir])
-        self.assertEqual(rc, batch_cli.EXIT_FATAL)
-        line = buf.getvalue().strip().splitlines()[0]
-        payload = json.loads(line)
-        self.assertFalse(payload.get("success"))
-
-    def test_status_for_missing_job_returns_fatal(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            with redirect_stdout(io.StringIO()):
-                rc = batch_cli.main(
-                    ["status", "job-does-not-exist", "--project-root", tmp]
-                )
-        self.assertEqual(rc, batch_cli.EXIT_FATAL)
-
-    def test_list_empty_returns_ok(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            with redirect_stdout(io.StringIO()):
-                rc = batch_cli.main(["list", "--project-root", tmp])
-        self.assertEqual(rc, batch_cli.EXIT_OK)
-
-    def test_exit_for_status_mapping(self):
-        self.assertEqual(batch_cli._exit_for_status("completed"), batch_cli.EXIT_OK)
-        self.assertEqual(
-            batch_cli._exit_for_status("completed_with_errors"),
-            batch_cli.EXIT_PARTIAL,
-        )
-        self.assertEqual(batch_cli._exit_for_status("canceled"), batch_cli.EXIT_CANCELED)
-        self.assertEqual(batch_cli._exit_for_status("queued"), batch_cli.EXIT_FATAL)
-        self.assertEqual(batch_cli._exit_for_status(None), batch_cli.EXIT_FATAL)
-
-
-class BatchCliJsonOutputShapeTests(unittest.TestCase):
-    def test_list_json_emits_single_payload(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            buf = io.StringIO()
-            with redirect_stdout(buf):
-                rc = batch_cli.main(["--json", "list", "--project-root", tmp])
-        self.assertEqual(rc, batch_cli.EXIT_OK)
-        lines = [line for line in buf.getvalue().splitlines() if line.strip()]
-        self.assertEqual(len(lines), 1)
-        payload = json.loads(lines[0])
-        self.assertTrue(payload.get("success"))
-        self.assertEqual(payload.get("jobs"), [])
-
-
-class BatchCliRunIntegrationTests(unittest.TestCase):
-    """End-to-end smoke test through the real engine with synthetic media."""
-
-    @staticmethod
-    def _write_synthetic_media(source: str) -> None:
-        subprocess.run(
-            [
-                "ffmpeg",
-                "-hide_banner",
-                "-loglevel",
-                "error",
-                "-y",
-                "-f",
-                "lavfi",
-                "-i",
-                "testsrc2=size=160x90:rate=24:duration=2",
-                "-f",
-                "lavfi",
-                "-i",
-                "sine=frequency=1000:duration=2",
-                "-c:v",
-                "mpeg4",
-                "-c:a",
-                "aac",
-                "-shortest",
-                source,
-            ],
-            check=True,
-        )
-
-    def test_run_drives_synthetic_job_to_completion(self):
-        if not shutil.which("ffmpeg") or not shutil.which("ffprobe"):
-            self.skipTest("ffmpeg/ffprobe not installed")
-        with tempfile.TemporaryDirectory() as tmp:
-            source_dir = os.path.join(tmp, "source")
-            analysis_dir = os.path.join(tmp, "analysis")
-            os.makedirs(source_dir)
-            source = os.path.join(source_dir, "cli_smoke.mp4")
-            self._write_synthetic_media(source)
-            caps = media_analysis_jobs.detect_capabilities()
-            caps["transcription"] = {"available": True, "backends": ["local_mock"]}
-
-            buf = io.StringIO()
-            with patch("src.utils.media_analysis_jobs.detect_capabilities", return_value=caps), redirect_stdout(buf):
-                rc = batch_cli.main(
-                    [
-                        "--json",
-                        "run",
-                        source,
-                        "--analysis-root",
-                        analysis_dir,
-                        "--project-name",
-                        "CLI smoke",
-                        "--depth",
-                        "quick",
-                        "--max-clips",
-                        "5",
-                    ]
-                )
-            self.assertEqual(rc, batch_cli.EXIT_OK)
-            lines = [line for line in buf.getvalue().splitlines() if line.strip()]
-            events = [json.loads(line) for line in lines]
-            self.assertEqual(events[0].get("event"), "job_created")
-            self.assertEqual(events[-1].get("event"), "job_done")
-            self.assertEqual(events[-1].get("status"), "completed")
-
-
-class BatchCliSpecCommandTests(unittest.TestCase):
-    """plan-spec / apply argparse plumbing + exit-code mapping. The spec action
-    itself (project_spec) is covered by tests/test_project_spec.py; here we mock
-    _run_spec_action so no Resolve connection is needed."""
-
-    def test_help_lists_spec_subcommands(self):
-        parser = batch_cli._build_parser()
-        with self.assertRaises(SystemExit):
-            with redirect_stdout(io.StringIO()) as buf:
-                parser.parse_args(["--help"])
-        text = buf.getvalue()
-        self.assertIn("plan-spec", text)
-        self.assertIn("apply", text)
-
-    def test_apply_requires_spec(self):
-        parser = batch_cli._build_parser()
-        with self.assertRaises(SystemExit):
-            with redirect_stdout(io.StringIO()), patch("sys.stderr", io.StringIO()):
-                parser.parse_args(["apply"])
-
-    def test_plan_spec_emits_plan_and_exits_ok(self):
-        plan = {"project": "Show", "change_count": 1,
-                "actions": [{"op": "create", "target": "project:Show", "detail": ""}],
-                "diff": {}}
-        with patch.object(batch_cli, "_run_spec_action", return_value=plan):
-            with redirect_stdout(io.StringIO()):
-                rc = batch_cli.main(["plan-spec", "/tmp/spec.json"])
-        self.assertEqual(rc, batch_cli.EXIT_OK)
-
-    def test_apply_success_exit_ok(self):
-        result = {"success": True, "applied_count": 3, "applied": [], "failures": []}
-        with patch.object(batch_cli, "_run_spec_action", return_value=result):
-            with redirect_stdout(io.StringIO()):
-                rc = batch_cli.main(["apply", "/tmp/spec.json"])
-        self.assertEqual(rc, batch_cli.EXIT_OK)
-
-    def test_apply_partial_exit_2(self):
-        result = {"success": False, "applied_count": 1, "applied": [],
-                  "failures": [{"target": "timeline:A"}]}
-        with patch.object(batch_cli, "_run_spec_action", return_value=result):
-            with redirect_stdout(io.StringIO()):
-                rc = batch_cli.main(["apply", "/tmp/spec.json"])
-        self.assertEqual(rc, batch_cli.EXIT_PARTIAL)
-
-    def test_not_connected_exit_fatal(self):
-        with patch.object(batch_cli, "_run_spec_action", return_value=None):
-            with redirect_stdout(io.StringIO()):
-                rc = batch_cli.main(["apply", "/tmp/spec.json"])
-        self.assertEqual(rc, batch_cli.EXIT_FATAL)
-
-    def test_spec_error_envelope_exit_fatal(self):
-        result = {"error": {"message": "bad spec", "category": "invalid_input"}}
-        with patch.object(batch_cli, "_run_spec_action", return_value=result):
-            with redirect_stdout(io.StringIO()):
-                rc = batch_cli.main(["plan-spec", "/tmp/spec.json"])
-        self.assertEqual(rc, batch_cli.EXIT_FATAL)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,218 +0,0 @@
-"""Unit tests for src/utils/brain_edits.py (C6).
-
-No Resolve required. Mocks the timeline handle where metric capture is needed.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import tempfile
-import unittest
-
-from src.utils import brain_edits, timeline_brain_db
-
-
-class _MockTimeline:
-    """Minimal timeline mock for capture_* helpers."""
-
-    def __init__(
-        self,
-        *,
-        start: int = 0,
-        end: int = 240,
-        fps: float = 24.0,
-        clips_per_track: tuple[int, ...] = (3,),
-        gaps: tuple[tuple[int, int], ...] = (),
-    ) -> None:
-        self._start = start
-        self._end = end
-        self._fps = fps
-        # `gaps` is a list of (start, end) pairs that represent empty space; we
-        # synthesise track items around them so capture_timeline_gap_stats sees
-        # the gaps.
-        self._gaps = gaps
-        self._clips_per_track = clips_per_track
-
-    def GetStartFrame(self): return self._start
-    def GetEndFrame(self): return self._end
-    def GetSetting(self, key): return str(self._fps) if key == "timelineFrameRate" else None
-
-    def GetTrackCount(self, tt):
-        if tt == "video":
-            return len(self._clips_per_track)
-        return 0
-
-    def GetItemListInTrack(self, tt, idx):
-        if tt != "video":
-            return []
-        # Walk from start; for each gap, produce a clip ending at gap[0] and
-        # the next clip starting at gap[1].
-        items: list[object] = []
-        cursor = self._start
-        for gap_start, gap_end in self._gaps:
-            items.append(_MockItem(cursor, gap_start))
-            cursor = gap_end
-        items.append(_MockItem(cursor, self._end))
-        return items
-
-
-class _MockItem:
-    def __init__(self, start: int, end: int) -> None:
-        self._start = start
-        self._end = end
-
-    def GetStart(self): return self._start
-    def GetEnd(self): return self._end
-
-
-class BrainEdits(unittest.TestCase):
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="brain_edits_test_")
-        # Need TWO project roots that share a base, to exercise the registry.
-        self.base = self.tmp
-        self.project_root = os.path.join(self.base, "project_a")
-        self.other_project_root = os.path.join(self.base, "project_b")
-        os.makedirs(self.project_root, exist_ok=True)
-        os.makedirs(self.other_project_root, exist_ok=True)
-
-    def tearDown(self) -> None:
-        timeline_brain_db.reset_for_test(self.project_root)
-        timeline_brain_db.reset_for_test(self.other_project_root)
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    # ── capture helpers ──
-
-    def test_capture_duration_seconds(self) -> None:
-        tl = _MockTimeline(start=0, end=240, fps=24.0)
-        self.assertEqual(brain_edits.capture_timeline_duration_seconds(tl), 10.0)
-
-    def test_capture_duration_handles_zero_fps(self) -> None:
-        tl = _MockTimeline(fps=0.0)
-        self.assertIsNone(brain_edits.capture_timeline_duration_seconds(tl))
-
-    def test_capture_gap_stats(self) -> None:
-        tl = _MockTimeline(start=0, end=240, fps=24.0, gaps=((48, 72), (120, 144)))
-        stats = brain_edits.capture_timeline_gap_stats(tl)
-        self.assertEqual(stats["gap_count"], 2)
-        self.assertEqual(stats["total_gap_frames"], 24 + 24)
-        self.assertEqual(stats["total_gap_seconds"], 2.0)
-
-    def test_capture_clip_count(self) -> None:
-        tl = _MockTimeline(gaps=((48, 72),))  # 2 clips on one track
-        self.assertEqual(brain_edits.capture_timeline_clip_count(tl), 2)
-
-    def test_capture_metric_dispatch(self) -> None:
-        tl = _MockTimeline(start=0, end=240, fps=24.0)
-        self.assertEqual(brain_edits.capture_metric("duration_seconds", tl), 10.0)
-        self.assertIsNone(brain_edits.capture_metric("unknown_metric", tl))
-
-    # ── log + query ──
-
-    def test_log_brain_edit_persists_and_returns_id(self) -> None:
-        result = brain_edits.log_brain_edit(
-            project_root=self.project_root,
-            analysis_run_id="run_1",
-            edit_type="timeline.delete_clips",
-            tool_name="timeline",
-            action_name="delete_clips",
-            timeline_before="Edit_v01",
-            timeline_after="Edit_v01",
-            target_metric="duration_seconds",
-            metric_direction="decrease",
-            before_value=120.0,
-            after_value=100.0,
-            rationale="trimmed slack",
-            project_name="project_a",
-        )
-        self.assertTrue(result["success"])
-        self.assertIsNotNone(result["row_id"])
-
-    def test_get_brain_edit_history_filters(self) -> None:
-        for i, run_id in enumerate(["run_a", "run_b", "run_a"], start=1):
-            brain_edits.log_brain_edit(
-                project_root=self.project_root,
-                analysis_run_id=run_id,
-                edit_type="timeline.delete_clips",
-                timeline_before=f"Edit_v0{i}",
-                timeline_after=f"Edit_v0{i}",
-                project_name="project_a",
-            )
-        all_history = brain_edits.get_brain_edit_history(project_root=self.project_root)
-        self.assertEqual(len(all_history), 3)
-        run_a_only = brain_edits.get_brain_edit_history(
-            project_root=self.project_root, analysis_run_id="run_a"
-        )
-        self.assertEqual(len(run_a_only), 2)
-
-    def test_delta_computed_when_both_values_present(self) -> None:
-        brain_edits.log_brain_edit(
-            project_root=self.project_root,
-            analysis_run_id="run_delta",
-            edit_type="timeline.delete_clips",
-            before_value=120.0,
-            after_value=100.0,
-            project_name="project_a",
-        )
-        rows = brain_edits.get_brain_edit_history(
-            project_root=self.project_root, analysis_run_id="run_delta",
-        )
-        self.assertEqual(rows[0]["delta"], -20.0)
-
-    def test_rejects_invalid_direction(self) -> None:
-        result = brain_edits.log_brain_edit(
-            project_root=self.project_root,
-            analysis_run_id="bad",
-            edit_type="x",
-            metric_direction="sideways",
-            project_name="project_a",
-        )
-        self.assertFalse(result["success"])
-
-    # ── cross-project registry ──
-
-    def test_registry_aggregates_across_projects(self) -> None:
-        brain_edits.log_brain_edit(
-            project_root=self.project_root,
-            analysis_run_id="run_x",
-            edit_type="timeline.delete_clips",
-            project_name="project_a",
-        )
-        brain_edits.log_brain_edit(
-            project_root=self.other_project_root,
-            analysis_run_id="run_y",
-            edit_type="timeline.create_compound_clip",
-            project_name="project_b",
-        )
-        # Both projects share `self.base` as the base root; the registry should
-        # live there and contain both entries.
-        registry_path = os.path.join(self.base, brain_edits.REGISTRY_FILENAME)
-        self.assertTrue(os.path.isfile(registry_path), msg="registry not created")
-        with open(registry_path, "r") as fh:
-            payload = json.load(fh)
-        project_names = {e["project_name"] for e in payload["entries"]}
-        self.assertEqual(project_names, {"project_a", "project_b"})
-
-    def test_registry_handles_corrupt_file(self) -> None:
-        registry_path = os.path.join(self.base, brain_edits.REGISTRY_FILENAME)
-        with open(registry_path, "w") as fh:
-            fh.write("not json {")
-        # Should not raise — corrupt registry is replaced fresh.
-        brain_edits.log_brain_edit(
-            project_root=self.project_root,
-            analysis_run_id="run_resilient",
-            edit_type="x",
-            project_name="project_a",
-        )
-        with open(registry_path, "r") as fh:
-            payload = json.load(fh)
-        self.assertEqual(len(payload["entries"]), 1)
-
-    def test_read_brain_edits_registry_no_file(self) -> None:
-        payload = brain_edits.read_brain_edits_registry(self.project_root)
-        self.assertEqual(payload["entries"], [])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,52 +0,0 @@
-"""Tests for the bridge-call counting instrumentation."""
-import unittest
-
-from src.utils.bridge_metrics import CountingProxy, measure
-
-
-class Inner:
-    def Val(self):
-        return 7
-
-
-class Outer:
-    prop = 5
-
-    def GetInner(self):
-        return Inner()
-
-    def GetList(self):
-        return [Inner(), Inner()]
-
-
-class CountingProxyTest(unittest.TestCase):
-    def test_counts_attr_access_and_calls(self):
-        c = {}
-        p = CountingProxy(Outer(), c)
-        self.assertEqual(p.prop, 5)            # attr_access
-        inner = p.GetInner()                   # attr_access + call, wrapped
-        self.assertEqual(inner.Val(), 7)       # attr_access + call -> primitive
-        self.assertEqual(c["attr_access"], 3)
-        self.assertEqual(c["calls"], 2)
-
-    def test_wraps_list_elements(self):
-        c = {}
-        p = CountingProxy(Outer(), c)
-        items = p.GetList()                    # attr_access + call
-        for it in items:
-            it.Val()                           # 2x (attr_access + call) each
-        self.assertEqual(c["calls"], 3)        # GetList + 2 Val
-        self.assertEqual(c["attr_access"], 3)  # GetList + 2 Val
-
-    def test_primitives_not_wrapped(self):
-        c = {}
-        p = CountingProxy(Outer(), c)
-        self.assertIsInstance(p.prop, int)
-
-    def test_measure_helper(self):
-        counts = measure(lambda px: px.GetInner().Val(), Outer())
-        self.assertEqual(counts["calls"], 2)
-
-
-if __name__ == "__main__":
-    unittest.main()