davinci-resolve-mcp 2.41.0 → 2.43.0

package/src/utils/media_analysis.py

@@ -1436,6 +1436,28 @@ TOOL_INSTALL: Dict[str, Dict[str, Any]] = {
         "verify": "whisper --help",
         "notes": "Pure-Python reference implementation. Choose this OR whisper_cpp OR mlx_whisper.",
     },
+    "ollama_embeddings": {
+        "label": "ollama + nomic-embed-text",
+        "bundle": "embeddings",
+        "required_for": ["semantic search (text embeddings)", "find_similar"],
+        "commands": {
+            "macos": "brew install ollama && ollama pull nomic-embed-text",
+            "linux": "curl -fsSL https://ollama.com/install.sh | sh && ollama pull nomic-embed-text",
+            "windows": "winget install Ollama.Ollama, then: ollama pull nomic-embed-text",
+        },
+        "verify": "ollama list",
+        "notes": "Local embedding model (~270 MB). sentence-transformers is an alternative text backend.",
+    },
+    "open_clip": {
+        "label": "open_clip (CLIP visual embeddings)",
+        "bundle": "embeddings",
+        "required_for": ["visual similarity (find_similar kind=visual)", "cross-clip entity clustering"],
+        "commands": {
+            "all": "pip install open_clip_torch",
+        },
+        "verify": "python -c \"import open_clip\"",
+        "notes": "Needs torch. Model weights (~350 MB) download on first use.",
+    },
     "whisper_cpp": {
         "label": "whisper.cpp",
         "bundle": "transcription",
@@ -1585,6 +1607,17 @@ def detect_capabilities(env: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
 
     sync_events = detect_sync_event_capabilities()
 
+    # Phase C — embedding backends (detected like the whisper backends; the
+    # ollama probe is a short local HTTP call and fails fast when not serving).
+    try:
+        from src.utils import embeddings as _embeddings
+
+        embedding_caps = _embeddings.detect_embedding_capabilities()
+    except Exception:  # noqa: BLE001 — detection must never break capabilities
+        embedding_caps = {"text": {"available": False, "backends": []},
+                          "visual": {"available": False, "backends": []},
+                          "install_guidance": {}}
+
     platform_id, machine = _runtime_platform_id()
 
     def _tool_entry(name: str, available: bool, extra: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
@@ -1607,7 +1640,18 @@ def detect_capabilities(env: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
             "whisper_cpp": _tool_entry("whisper_cpp", bool(whisper_cpp), {"path": whisper_cpp}),
             "mlx_whisper": _tool_entry("mlx_whisper", bool(mlx_whisper), {"python_module": "mlx_whisper"}),
             "opencv": _tool_entry("opencv", bool(cv2), {"python_module": "cv2"}),
+            "ollama_embeddings": _tool_entry(
+                "ollama_embeddings",
+                bool(embedding_caps.get("text", {}).get("available")),
+                {"backends": embedding_caps.get("text", {}).get("backends", [])},
+            ),
+            "open_clip": _tool_entry(
+                "open_clip",
+                bool(embedding_caps.get("visual", {}).get("available")),
+                {"python_module": "open_clip"},
+            ),
         },
+        "embeddings": embedding_caps,
         "transcription": {
             "available": bool(whisper_cli or whisper_cpp or mlx_whisper),
             "backends": [
@@ -4265,7 +4309,7 @@ def build_host_chat_paths_payload(
     if refusal is not None:
         return refusal
 
-    return {
+    payload: Dict[str, Any] = {
         "success": True,
         "status": "pending_host_analysis",
         "provider": HOST_CHAT_PATHS_PROVIDER,
@@ -4327,6 +4371,21 @@ def build_host_chat_paths_payload(
             "the clip's analysis directory; commit_vision finishes the run."
         ),
     }
+    # Phase B — deep depth: each shot_descriptions entry must additionally
+    # carry the per-shot field groups. The extra keys flow through
+    # commit_vision → canonical blob → subjective_fields rows unchanged.
+    if str(options.get("depth") or "").lower() == "deep":
+        from src.utils import deep_vision as _deep_vision
+
+        payload["deep_shot_schema"] = _deep_vision.deep_shot_schema()
+        payload["deep_schema_reference"] = _deep_vision.DEEP_SHOT_SCHEMA_REFERENCE
+        payload["instructions"] += (
+            " DEEP PASS: in addition to `description`, every shot_descriptions "
+            "entry MUST include the field groups in `deep_shot_schema` (visual, "
+            "content, production, editorial, cuttability, confidence), using the "
+            "enum values verbatim and 'unknown'/null when frame evidence is thin."
+        )
+    return payload
 
 
 def _vision_analysis(record: Dict[str, Any], motion: Dict[str, Any], options: Dict[str, Any], artifacts: Dict[str, Any], capabilities: Dict[str, Any]) -> Dict[str, Any]:
@@ -5096,6 +5155,9 @@ async def execute_plan_async(
         # Same for project_root — caps recording needs it to address the per-
         # project usage DB; falling back to the plan's output_root is fine.
         "project_root": params.get("project_root") or output_root,
+        # Phase B — depth threads into the vision payload builder so deep runs
+        # carry the per-shot field-group schema.
+        "depth": plan.get("depth", DEFAULT_DEPTH),
     }
     keep_frame_artifacts_for_vision = vision_uses_chat_context(options, caps)
     depth = plan.get("depth", DEFAULT_DEPTH)
@@ -5114,6 +5176,37 @@ async def execute_plan_async(
     }
     _write_json(os.path.join(output_root, "capabilities.json"), caps)
 
+    # Phase B — deep depth is opt-in with an explicit cost estimate first.
+    # The per-shot field-group pass multiplies vision spend, so the first call
+    # returns the estimate; re-call with confirm_deep=true to run. Caps still
+    # apply downstream — confirmation does not bypass budgets.
+    if (
+        depth == "deep"
+        and vision_uses_chat_context(options, caps)
+        and not _coerce_bool(params.get("confirm_deep") or params.get("confirmDeep"), default=False)
+    ):
+        executing = [
+            clip for clip in plan.get("clips", [])
+            if not (clip.get("skip_execution") and (clip.get("existing_report") or {}).get("path"))
+        ]
+        estimated_frames = sum(int(c.get("analysis_keyframe_budget") or 0) for c in executing)
+        return {
+            "success": True,
+            "status": "confirmation_required",
+            "reason": "deep_depth_cost_estimate",
+            "estimate": {
+                "clip_count": len(executing),
+                "estimated_frames": estimated_frames,
+                "estimated_vision_tokens": estimated_frames * AVG_VISION_TOKENS_PER_FRAME,
+                "tokens_per_frame_assumption": AVG_VISION_TOKENS_PER_FRAME,
+            },
+            "note": (
+                "Deep analysis fills per-shot Visual/Content/Editorial field groups "
+                "and costs vision tokens accordingly. Re-call the same analyze action "
+                "with confirm_deep=true to proceed, or drop depth to 'standard'."
+            ),
+        }
+
     for clip_plan in plan.get("clips", []):
         record = clip_plan["record"]
         artifacts = clip_plan["artifacts"]

package/src/utils/timeline_brain_db.py

@@ -29,7 +29,7 @@ from typing import Callable, Dict, Iterator, Optional, Tuple
 
 logger = logging.getLogger("resolve-mcp.timeline-brain-db")
 
-SCHEMA_VERSION = 9
+SCHEMA_VERSION = 10
 DB_FILENAME = "timeline_brain.sqlite"
 SOUL_DIRNAME = "_soul"
 
@@ -687,6 +687,38 @@ def _migrate_v9_analysis_core(conn: sqlite3.Connection) -> None:
     )
 
 
+@register_migration(10)
+def _migrate_v10_embeddings(conn: sqlite3.Connection) -> None:
+    """C3 — embeddings for similarity search (Phase C of the analysis program).
+
+    One row per (entity, kind, model). Vectors are float32 BLOBs; similarity
+    is brute-force cosine in the app layer (thousands of rows, not millions).
+    `content_hash` fingerprints the embedded content so re-runs only re-embed
+    entities whose text/frames changed.
+    """
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS embeddings (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            entity_type TEXT NOT NULL CHECK(entity_type IN ('clip', 'shot', 'frame', 'segment')),
+            entity_uuid TEXT NOT NULL,
+            embedding_kind TEXT NOT NULL,        -- 'text' | 'visual'
+            model_name TEXT NOT NULL,
+            dimension INTEGER NOT NULL,
+            vector BLOB NOT NULL,
+            content_hash TEXT,
+            computed_at TEXT NOT NULL,
+            UNIQUE(entity_type, entity_uuid, embedding_kind, model_name)
+        );
+
+        CREATE INDEX IF NOT EXISTS ix_embeddings_kind
+            ON embeddings(embedding_kind, model_name);
+        CREATE INDEX IF NOT EXISTS ix_embeddings_entity
+            ON embeddings(entity_type, entity_uuid);
+        """
+    )
+
+
 def latest_version(conn: sqlite3.Connection, timeline_name: str) -> Optional[int]:
     """Return the highest archived version number for `timeline_name`, or None."""
     row = conn.execute(