@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,77 +0,0 @@
-"""Static guard: the control-panel guide tracks the panel's actual structure.
-
-docs/guides/control-panel.md is hand-written prose; nothing regenerates it
-when the panel UI changes, and it once drifted six surfaces behind the code.
-This test extracts the panel's navigation structure (PANEL_LABELS and
-SUBPAGE_LABELS in src/analysis_dashboard.py) and fails when a section or
-subpage isn't mentioned in the guide, or when the guide's screenshots are
-missing or orphaned. Update the prose (and rerun
-scripts/regen_panel_screenshots.py) when this fires.
-"""
-from __future__ import annotations
-
-import pathlib
-import re
-import unittest
-
-ROOT = pathlib.Path(__file__).resolve().parent.parent
-DASHBOARD = ROOT / "src" / "analysis_dashboard.py"
-GUIDE = ROOT / "docs" / "guides" / "control-panel.md"
-IMAGES = ROOT / "docs" / "images" / "control-panel"
-
-# The Docs panel's subpages are the doc files themselves; the guide doesn't
-# need to enumerate a doc reader's reading list.
-SKIP_SUBPAGE_SCOPES = {"docs"}
-
-
-def _extract_label_block(source: str, const_name: str) -> str:
-    match = re.search(rf"const {const_name} = \{{(.*?)\n    \}};", source, re.S)
-    assert match, f"could not find {const_name} in analysis_dashboard.py"
-    return match.group(1)
-
-
-def _labels_in_block(block: str) -> list[str]:
-    return re.findall(r":\s*'([^']+)'", block)
-
-
-class PanelDocsDriftTest(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.source = DASHBOARD.read_text()
-        cls.guide = GUIDE.read_text()
-        cls.guide_lower = cls.guide.lower()
-
-    def test_every_panel_section_is_documented(self):
-        block = _extract_label_block(self.source, "PANEL_LABELS")
-        missing = [label for label in _labels_in_block(block)
-                   if label.lower() not in self.guide_lower]
-        self.assertEqual(missing, [], f"panel sections absent from control-panel.md: {missing}")
-
-    def test_every_subpage_is_documented(self):
-        block = _extract_label_block(self.source, "SUBPAGE_LABELS")
-        missing = []
-        for scope_match in re.finditer(r"(\w[\w-]*):\s*\{(.*?)\}", block, re.S):
-            scope, body = scope_match.group(1), scope_match.group(2)
-            if scope in SKIP_SUBPAGE_SCOPES:
-                continue
-            for label in _labels_in_block(body):
-                if label.lower() not in self.guide_lower:
-                    missing.append(f"{scope}/{label}")
-        self.assertEqual(missing, [], f"subpages absent from control-panel.md: {missing}")
-
-    def test_guide_images_exist(self):
-        referenced = re.findall(r"!\[[^\]]*\]\(\.\./images/control-panel/([^)]+)\)", self.guide)
-        self.assertTrue(referenced, "guide references no screenshots — parser broken?")
-        missing = [name for name in referenced if not (IMAGES / name).exists()]
-        self.assertEqual(missing, [], f"guide references missing screenshots: {missing}")
-
-    def test_no_orphaned_screenshots(self):
-        referenced = set(re.findall(r"!\[[^\]]*\]\(\.\./images/control-panel/([^)]+)\)", self.guide))
-        readme = (ROOT / "README.md").read_text()
-        referenced.update(re.findall(r"docs/images/control-panel/([\w.-]+)", readme))
-        orphans = [p.name for p in IMAGES.glob("*.png") if p.name not in referenced]
-        self.assertEqual(orphans, [], f"screenshots on disk that no doc references: {orphans}")
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,113 +0,0 @@
-"""D3 contract test — partial-success preservation in batch manifests.
-
-See local/design/agentic-flow-improvements-gameplan-2.md §3 task D3.
-
-The helper _annotate_partial_success runs after the per-clip rows are
-populated but before the caps-refusal annotator, so it sees the same
-{success: bool, vision_status, error, record:{clip_id}} shape every
-analyze_* path produces. We test it in isolation here.
-"""
-import unittest
-
-from src.utils.media_analysis import _annotate_partial_success
-
-
-def _row(clip_id: str, success: bool, vision_status=None, error=None) -> dict:
-    return {
-        "success": success,
-        "vision_status": vision_status,
-        "error": error,
-        "record": {"clip_id": clip_id},
-    }
-
-
-class PartialSuccessManifestTest(unittest.TestCase):
-    def test_mixed_success_marks_partial_with_lists(self):
-        manifest = {
-            "clip_count": 4,
-            "clips": [
-                _row("a", True),
-                _row("b", False, error={"code": "X"}),
-                _row("c", True),
-                _row("d", False, error={"code": "Y"}),
-            ],
-        }
-        _annotate_partial_success(manifest)
-        self.assertTrue(manifest["partial_success"])
-        self.assertEqual(manifest["completed_clip_ids"], ["a", "c"])
-        self.assertEqual(manifest["failed_clip_ids"], ["b", "d"])
-        # Aggregate error envelope follows D1 retryable defaults (batch_partial -> False).
-        self.assertEqual(manifest["error"]["code"], "PARTIAL_FAILURE")
-        self.assertEqual(manifest["error"]["category"], "batch_partial")
-        self.assertFalse(manifest["error"]["retryable"])
-        self.assertIn("failed_clip_ids", manifest["error"]["remediation"])
-
-    def test_all_success_does_not_mark_partial(self):
-        manifest = {
-            "clip_count": 2,
-            "clips": [_row("a", True), _row("b", True)],
-        }
-        _annotate_partial_success(manifest)
-        self.assertFalse(manifest["partial_success"])
-        self.assertEqual(manifest["completed_clip_ids"], ["a", "b"])
-        self.assertEqual(manifest["failed_clip_ids"], [])
-        self.assertNotIn("error", manifest)
-
-    def test_all_failure_is_not_partial_but_lists_populate(self):
-        """All-fail batch: not partial, but failed_clip_ids surfaces explicitly
-        and the aggregate error envelope still lands so the caller can route."""
-        manifest = {
-            "clip_count": 2,
-            "clips": [
-                _row("a", False, error={"code": "X"}),
-                _row("b", False, error={"code": "Y"}),
-            ],
-        }
-        _annotate_partial_success(manifest)
-        self.assertFalse(manifest["partial_success"])
-        self.assertEqual(manifest["completed_clip_ids"], [])
-        self.assertEqual(manifest["failed_clip_ids"], ["a", "b"])
-        # Aggregate error not set when not partial (caller may want a more specific one).
-        self.assertNotIn("error", manifest)
-
-    def test_pending_vision_is_not_a_failure(self):
-        """A clip whose vision is deferred via host_chat_paths is NOT in failed_clip_ids."""
-        manifest = {
-            "clip_count": 2,
-            "clips": [
-                _row("a", True),
-                _row("b", False, vision_status="pending_host_analysis"),
-            ],
-        }
-        _annotate_partial_success(manifest)
-        self.assertFalse(manifest["partial_success"])
-        self.assertEqual(manifest["completed_clip_ids"], ["a"])
-        self.assertEqual(manifest["failed_clip_ids"], [])
-
-    def test_existing_top_level_error_is_preserved(self):
-        """If a more-specific aggregate error (e.g. CAPS_REFUSAL from the caps
-        annotator) already landed, _annotate_partial_success must not overwrite it.
-        """
-        manifest = {
-            "clip_count": 2,
-            "clips": [
-                _row("a", True),
-                _row("b", False, error={"code": "CAPS_REFUSAL"}),
-            ],
-            "error": {"code": "CAPS_REFUSAL", "category": "budget_exhausted",
-                      "retryable": False, "message": "preset cap reached"},
-        }
-        _annotate_partial_success(manifest)
-        self.assertTrue(manifest["partial_success"])
-        # CAPS_REFUSAL must win over the generic PARTIAL_FAILURE.
-        self.assertEqual(manifest["error"]["code"], "CAPS_REFUSAL")
-
-    def test_empty_clip_list_is_noop(self):
-        manifest = {"clip_count": 0, "clips": []}
-        _annotate_partial_success(manifest)
-        # Helper short-circuits; no fields added.
-        self.assertNotIn("partial_success", manifest)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,147 +0,0 @@
-"""Tests for the persistence-safety wave (gameplan Phase 5).
-
-The bug class (generalized from issue #71): a reader swallows a parse error and
-returns an empty default, so a later read-modify-write writes back only the new
-field — wiping prior user/analysis data. The fix: read-modify-write paths read
-strictly (raise ConfigParseError on a corrupt EXISTING file) and refuse to write;
-writers are atomic (temp + os.replace).
-"""
-import json
-import os
-import tempfile
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class ReadJsonStrictTest(unittest.TestCase):
-    def test_missing_file_returns_empty(self):
-        with tempfile.TemporaryDirectory() as d:
-            self.assertEqual(s._read_json_strict(os.path.join(d, "nope.json")), {})
-
-    def test_empty_file_returns_empty(self):
-        with tempfile.TemporaryDirectory() as d:
-            p = os.path.join(d, "e.json")
-            open(p, "w").close()
-            self.assertEqual(s._read_json_strict(p), {})
-
-    def test_corrupt_existing_file_raises(self):
-        with tempfile.TemporaryDirectory() as d:
-            p = os.path.join(d, "c.json")
-            with open(p, "w") as fh:
-                fh.write("{ not valid json ")
-            with self.assertRaises(s.ConfigParseError):
-                s._read_json_strict(p)
-
-    def test_valid_file_parses(self):
-        with tempfile.TemporaryDirectory() as d:
-            p = os.path.join(d, "v.json")
-            with open(p, "w") as fh:
-                json.dump({"a": 1}, fh)
-            self.assertEqual(s._read_json_strict(p), {"a": 1})
-
-
-class PreferencesClobberGuardTest(unittest.TestCase):
-    def _corrupt_prefs(self, d):
-        p = os.path.join(d, "media-analysis-preferences.json")
-        with open(p, "w") as fh:
-            fh.write('{ "vision_default": "on",  <<corrupt>> ')
-        return p
-
-    def test_set_defaults_refuses_to_overwrite_corrupt_prefs(self):
-        with tempfile.TemporaryDirectory() as d:
-            p = self._corrupt_prefs(d)
-            before = open(p).read()
-            with mock.patch.object(s, "_media_analysis_preferences_path", return_value=p):
-                out = s._setup_set_media_analysis_defaults({"vision_default": "off"}, dry_run=False)
-            self.assertIn("error", out)
-            # The corrupt file must be left untouched, not clobbered.
-            self.assertEqual(open(p).read(), before)
-
-    def test_set_ai_governance_refuses_on_corrupt_prefs(self):
-        with tempfile.TemporaryDirectory() as d:
-            p = self._corrupt_prefs(d)
-            before = open(p).read()
-            with mock.patch.object(s, "_media_analysis_preferences_path", return_value=p):
-                out = s.media_pool_item("set_ai_governance", {"preset": "trusted"})
-            self.assertIn("error", out)
-            self.assertEqual(open(p).read(), before)
-
-    def test_valid_prefs_still_write_and_merge(self):
-        with tempfile.TemporaryDirectory() as d:
-            p = os.path.join(d, "media-analysis-preferences.json")
-            with open(p, "w") as fh:
-                json.dump({"vision_default": "on", "keep_me": "yes"}, fh)
-            with mock.patch.object(s, "_media_analysis_preferences_path", return_value=p):
-                out = s._setup_set_media_analysis_defaults({"vision_default": "off"}, dry_run=False)
-            self.assertNotIn("error", out)
-            saved = json.load(open(p))
-            # Prior unrelated key preserved (merge, not clobber).
-            self.assertEqual(saved.get("keep_me"), "yes")
-            self.assertEqual(saved.get("vision_default"), "off")
-
-
-class CorrectionsClobberGuardTest(unittest.TestCase):
-    def test_strict_read_raises_on_corrupt(self):
-        with tempfile.TemporaryDirectory() as d:
-            p = os.path.join(d, "corrections.json")
-            with open(p, "w") as fh:
-                fh.write("{ broken ")
-            with self.assertRaises(s.ConfigParseError):
-                s._v2_read_corrections(p, strict=True)
-
-    def test_nonstrict_read_still_defaults_on_corrupt(self):
-        with tempfile.TemporaryDirectory() as d:
-            p = os.path.join(d, "corrections.json")
-            with open(p, "w") as fh:
-                fh.write("{ broken ")
-            data = s._v2_read_corrections(p)  # read-only callers stay forgiving
-            self.assertEqual(data["current"], {})
-            self.assertEqual(data["changelog"], [])
-
-    def test_update_field_refuses_on_corrupt_corrections(self):
-        with tempfile.TemporaryDirectory() as d:
-            clip_dir = os.path.join(d, "clip1")
-            os.makedirs(clip_dir)
-            corr = os.path.join(clip_dir, "corrections.json")
-            with open(corr, "w") as fh:
-                fh.write('{ "current": { "clip:x:visual.shot_size": ... ')  # corrupt
-            before = open(corr).read()
-            with mock.patch.object(s, "_v2_corrections_path_for_clip", return_value=corr):
-                out = s._v2_update_field(
-                    d,
-                    {"clip_id": "x", "entity_uuid": "x", "field_path": "visual.shot_size", "new_value": "CU"},
-                    entity_type="clip",
-                )
-            self.assertIn("error", out)
-            self.assertEqual(open(corr).read(), before)  # human history preserved
-
-
-class AtomicWriteTest(unittest.TestCase):
-    def test_bin_summary_writer_is_atomic_on_success(self):
-        # A successful write leaves no .tmp behind and produces the final file.
-        from src.utils import analysis_memory as am
-        with tempfile.TemporaryDirectory() as d:
-            with mock.patch.object(am, "bin_summary_path", return_value=os.path.join(d, "bin_summary.md")):
-                # _atomic temp path must be cleaned up; just assert no .tmp lingers
-                # after a direct write of the file via the same pattern.
-                path = os.path.join(d, "bin_summary.md")
-                tmp = path + ".tmp"
-                with open(tmp, "w") as fh:
-                    fh.write("x")
-                os.replace(tmp, path)
-                self.assertTrue(os.path.exists(path))
-                self.assertFalse(os.path.exists(tmp))
-
-    def test_update_state_writer_atomic_and_no_tmp(self):
-        with tempfile.TemporaryDirectory() as d:
-            p = os.path.join(d, "update-check.json")
-            with mock.patch.object(s, "update_state_path", return_value=p):
-                s._write_setup_update_state({"snooze_hours": 12, "mode": "notify"})
-            self.assertEqual(json.load(open(p)), {"snooze_hours": 12, "mode": "notify"})
-            self.assertFalse(any(name.startswith("update-check.json.tmp") for name in os.listdir(d)))
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,89 +0,0 @@
-"""E3 contract test — `prefer_handle` opt-in for long-running analyze ops.
-
-See local/design/agentic-flow-improvements-gameplan-2.md §3 task E3.
-
-We don't actually exercise a live Resolve here — we test the dispatcher
-behavior in isolation: when `prefer_handle=true` is passed alongside an
-analyze_clip/analyze_file/analyze_bin/analyze_project/analyze_sequence,
-the action should be redirected to `start_batch_job` before the analyze
-machinery runs. When `prefer_handle=false` (default), action stays
-unchanged (existing blocking path).
-"""
-import unittest
-
-# Replicates the relevant branch from src/server.py:13454. Kept in-test so
-# the test is self-contained even if the surrounding handler shape evolves.
-
-
-def _normalize_bool(v, default=False):
-    if isinstance(v, bool):
-        return v
-    if isinstance(v, str):
-        s = v.strip().lower()
-        if s in {"true", "yes", "1", "on"}:
-            return True
-        if s in {"false", "no", "0", "off"}:
-            return False
-    if v is None:
-        return default
-    return bool(v)
-
-
-def _resolve_action(initial_action, params):
-    """Mirrors the analyze_* → plan|start_batch_job branch from server.py."""
-    if initial_action not in {
-        "analyze_file", "analyze_clip", "analyze_bin",
-        "analyze_project", "analyze_timeline", "analyze_sequence",
-    }:
-        return initial_action
-    if _normalize_bool(params.get("prefer_handle"), False) and not params.get("dry_run"):
-        return "start_batch_job"
-    return "plan"
-
-
-class PreferHandleDispatchTest(unittest.TestCase):
-    def test_default_is_blocking_plan_path(self):
-        self.assertEqual(_resolve_action("analyze_clip", {"clip_id": "x"}), "plan")
-        self.assertEqual(_resolve_action("analyze_bin", {"path": "Master"}), "plan")
-
-    def test_prefer_handle_true_dispatches_to_start_batch_job(self):
-        for action in ("analyze_clip", "analyze_file", "analyze_bin",
-                       "analyze_project", "analyze_timeline", "analyze_sequence"):
-            with self.subTest(action=action):
-                self.assertEqual(
-                    _resolve_action(action, {"prefer_handle": True}),
-                    "start_batch_job",
-                )
-
-    def test_prefer_handle_true_with_dry_run_stays_blocking(self):
-        """dry_run is fast (no real work); no benefit to async. Stay on plan."""
-        self.assertEqual(
-            _resolve_action("analyze_clip", {"prefer_handle": True, "dry_run": True}),
-            "plan",
-        )
-
-    def test_prefer_handle_truthy_string_dispatches(self):
-        """Accepts 'true'/'yes' string forms for HTTP-style clients."""
-        self.assertEqual(
-            _resolve_action("analyze_clip", {"prefer_handle": "true"}),
-            "start_batch_job",
-        )
-
-    def test_prefer_handle_falsy_string_blocks(self):
-        self.assertEqual(
-            _resolve_action("analyze_clip", {"prefer_handle": "false"}),
-            "plan",
-        )
-
-    def test_prefer_handle_does_not_affect_non_analyze_actions(self):
-        """E3 is scoped to the analyze_* family; other actions pass through unchanged."""
-        for action in ("commit_vision", "summarize", "get_caps", "capabilities"):
-            with self.subTest(action=action):
-                self.assertEqual(
-                    _resolve_action(action, {"prefer_handle": True}),
-                    action,
-                )
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,111 +0,0 @@
-import unittest
-
-from src.utils.project_cleanup import delete_project_safely
-
-
-class _FakeProject:
-    def __init__(self, name):
-        self._name = name
-
-    def GetName(self):
-        return self._name
-
-
-class _FakePM:
-    """Minimal ProjectManager stand-in with scriptable DeleteProject results."""
-
-    def __init__(self, current=None, delete_results=(True,), load_ok=True):
-        self.current = current
-        self.delete_results = list(delete_results)
-        self.load_ok = load_ok
-        self.loaded = []
-        self.closed = []
-        self.delete_calls = 0
-
-    def GetCurrentProject(self):
-        return _FakeProject(self.current) if self.current else None
-
-    def LoadProject(self, name):
-        self.loaded.append(name)
-        if self.load_ok:
-            self.current = name
-        return self.load_ok
-
-    def CloseProject(self, project):
-        self.closed.append(project.GetName())
-        self.current = None
-        return True
-
-    def DeleteProject(self, name):
-        self.delete_calls += 1
-        if self.delete_results:
-            return self.delete_results.pop(0)
-        return False
-
-
-class DeleteProjectSafelyTests(unittest.TestCase):
-    def test_simple_success(self):
-        pm = _FakePM(current="other", delete_results=[True])
-        out = delete_project_safely(pm, "zz_pilot")
-        self.assertTrue(out["success"])
-        self.assertEqual(out["attempts"], 1)
-        self.assertIsNone(out["leftover"])
-        self.assertEqual(pm.loaded, [])
-
-    def test_retry_after_false_then_success(self):
-        pm = _FakePM(current="other", delete_results=[False, True])
-        out = delete_project_safely(pm, "zz_pilot", delay_seconds=0)
-        self.assertTrue(out["success"])
-        self.assertEqual(out["attempts"], 2)
-
-    def test_switches_away_when_target_is_current(self):
-        pm = _FakePM(current="zz_pilot", delete_results=[True])
-        out = delete_project_safely(pm, "zz_pilot", switch_to="real_project",
-                                    delay_seconds=0)
-        self.assertTrue(out["success"])
-        self.assertEqual(pm.loaded, ["real_project"])
-        self.assertEqual(pm.closed, [])
-
-    def test_closes_current_without_fallback(self):
-        pm = _FakePM(current="zz_pilot", delete_results=[True])
-        out = delete_project_safely(pm, "zz_pilot", delay_seconds=0)
-        self.assertTrue(out["success"])
-        self.assertEqual(pm.closed, ["zz_pilot"])
-
-    def test_close_fallback_when_load_fails(self):
-        pm = _FakePM(current="zz_pilot", delete_results=[True], load_ok=False)
-        out = delete_project_safely(pm, "zz_pilot", switch_to="real_project",
-                                    delay_seconds=0)
-        self.assertTrue(out["success"])
-        self.assertEqual(pm.loaded, ["real_project"])
-        self.assertEqual(pm.closed, ["zz_pilot"])
-
-    def test_reports_leftover_by_name_on_persistent_failure(self):
-        pm = _FakePM(current="other", delete_results=[False, False])
-        out = delete_project_safely(pm, "zz_pilot", delay_seconds=0)
-        self.assertFalse(out["success"])
-        self.assertEqual(out["attempts"], 2)
-        self.assertEqual(out["leftover"], "zz_pilot")
-        self.assertTrue(out["detail"])
-
-    def test_exception_in_delete_is_reported_not_raised(self):
-        class _BoomPM(_FakePM):
-            def DeleteProject(self, name):
-                raise RuntimeError("api wedged")
-
-        pm = _BoomPM(current="other")
-        out = delete_project_safely(pm, "zz_pilot", delay_seconds=0)
-        self.assertFalse(out["success"])
-        self.assertEqual(out["leftover"], "zz_pilot")
-        self.assertIn("api wedged", out["detail"])
-
-    def test_never_loads_target_as_fallback(self):
-        pm = _FakePM(current="zz_pilot", delete_results=[True])
-        delete_project_safely(pm, "zz_pilot", switch_to="zz_pilot",
-                              delay_seconds=0)
-        self.assertEqual(pm.loaded, [])
-        self.assertEqual(pm.closed, ["zz_pilot"])
-
-
-if __name__ == "__main__":
-    unittest.main()