@hybridlabor-api/aos 4.4.1 → 4.4.2-beta.1

package/mcps/davinci-resolve-mcp/src/utils/contracts.py

@@ -1,102 +0,0 @@
-"""Declarative parameter validation for compound-tool actions.
-
-Input validation in the server has historically been scattered: hand-built
-"Must be one of" strings, ad-hoc empty/range/path checks inline in each action.
-This module centralizes it into one declarative validator that emits consistent,
-agent-friendly error messages, so the validation bug class is closed once rather
-than patched action by action.
-
-Usage:
-
-    err, clean = validate(params, {
-        "path": {"type": str, "required": True, "non_empty": True, "parent_dir_exists": True},
-        "mark_in": {"type": int, "required": True},
-        "mark_out": {"type": int, "required": True},
-        "kind": {"enum": ["all", "video", "audio"], "default": "all"},
-    }, invariants=[
-        lambda c: "mark_in must be <= mark_out" if c["mark_in"] > c["mark_out"] else None,
-    ])
-    if err:
-        return _err(err)
-    # use clean[...] — coerced + defaulted
-
-Rule keys: ``type`` (int/str/float/bool), ``required``, ``default``, ``enum``,
-``min``, ``max``, ``non_empty`` (str), ``parent_dir_exists`` (str path).
-"""
-import os
-from typing import Any, Callable, Dict, List, Optional, Tuple
-
-
-def _coerce(name: str, value: Any, t: type) -> Tuple[Any, Optional[str]]:
-    if t is bool:
-        if isinstance(value, bool):
-            return value, None
-        if isinstance(value, str):
-            return value.strip().lower() in ("1", "true", "yes", "on"), None
-        return bool(value), None
-    if t is int:
-        try:
-            return int(value), None
-        except (TypeError, ValueError):
-            return None, f"'{name}' must be an integer"
-    if t is float:
-        try:
-            return float(value), None
-        except (TypeError, ValueError):
-            return None, f"'{name}' must be a number"
-    if t is str:
-        if not isinstance(value, str):
-            return None, f"'{name}' must be a string"
-        return value, None
-    return value, None
-
-
-def validate(
-    params: Dict[str, Any],
-    rules: Dict[str, Dict[str, Any]],
-    invariants: Optional[List[Callable[[Dict[str, Any]], Optional[str]]]] = None,
-) -> Tuple[Optional[str], Optional[Dict[str, Any]]]:
-    """Validate ``params`` against ``rules``.
-
-    Returns ``(None, cleaned)`` on success (cleaned has coercions + defaults
-    applied), or ``(error_message, None)`` on the first violation.
-    """
-    cleaned = dict(params)
-
-    for name, rule in rules.items():
-        present = name in params and params[name] is not None
-        if not present:
-            if rule.get("required"):
-                return f"'{name}' is required", None
-            if "default" in rule:
-                cleaned[name] = rule["default"]
-            continue
-
-        val = params[name]
-        t = rule.get("type")
-        if t is not None:
-            val, err = _coerce(name, val, t)
-            if err:
-                return err, None
-
-        if "enum" in rule and val not in rule["enum"]:
-            return f"'{name}' must be one of: {', '.join(map(str, rule['enum']))}", None
-        if rule.get("non_empty") and isinstance(val, str) and not val.strip():
-            return f"'{name}' must be non-empty", None
-        if "min" in rule and val < rule["min"]:
-            return f"'{name}' must be >= {rule['min']}", None
-        if "max" in rule and val > rule["max"]:
-            return f"'{name}' must be <= {rule['max']}", None
-        if rule.get("parent_dir_exists"):
-            parent = os.path.dirname(os.path.expanduser(str(val)))
-            if parent and not os.path.isdir(parent):
-                return f"'{name}' target directory does not exist: {parent}", None
-
-        cleaned[name] = val
-
-    for inv in (invariants or []):
-        msg = inv(cleaned)
-        if msg:
-            return msg, None
-
-    return None, cleaned

package/mcps/davinci-resolve-mcp/src/utils/cut_ir.py

@@ -1,115 +0,0 @@
-"""Cut intermediate representation (Cut-IR) and the mechanical (Pass-1) detector.
-
-The Cut-IR is the typed contract between a timestamped transcript and concrete,
-governed timeline operations. Producers emit Cuts; an executor (a later phase)
-consumes them as governed, versioned edits; a review UI shows them. This module
-provides the schema plus the deterministic Pass-1 detector — filler words, long
-pauses, and repeated lines — with no LLM. The semantic Pass-2 and the timeline
-executor are separate phases (see local/design/research/r1-cut-ir.md).
-
-A Cut:
-    {
-      "kind": "filler" | "long_pause" | "stammer" | "false_start" | "semantic",
-      "span": {"start": <frame>, "end": <frame>},
-      "action": "lift" | "ripple_delete" | "keep" | "reorder" | "swap",
-      "confidence": 0.0..1.0,
-      "rationale": str,
-      "evidence": {...},
-    }
-"""
-from typing import Any, Dict, List, Optional
-
-# Common English fillers (single tokens and short phrases).
-FILLER_WORDS = {
-    "um", "uh", "er", "ah", "eh", "hmm", "mm", "uhh", "umm",
-    "like", "so", "well", "right", "okay", "ok",
-}
-FILLER_PHRASES = {"you know", "i mean", "sort of", "kind of", "you see"}
-
-
-def make_cut(
-    kind: str,
-    start: Optional[int],
-    end: Optional[int],
-    action: str,
-    confidence: float,
-    rationale: str,
-    evidence: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    return {
-        "kind": kind,
-        "span": {"start": start, "end": end},
-        "action": action,
-        "confidence": round(float(confidence), 2),
-        "rationale": rationale,
-        "evidence": evidence or {},
-    }
-
-
-def _norm(text: str) -> str:
-    return (text or "").strip().lower().strip(".,!?;:")
-
-
-def _is_filler_only(text: str) -> bool:
-    low = _norm(text)
-    if not low:
-        return False
-    if low in FILLER_PHRASES:
-        return True
-    tokens = [t.strip(".,!?;:") for t in low.split()]
-    tokens = [t for t in tokens if t]
-    return bool(tokens) and all(t in FILLER_WORDS for t in tokens)
-
-
-def detect_cuts_pass1(
-    cues: List[Dict[str, Any]],
-    *,
-    long_pause_frames: int = 48,
-) -> List[Dict[str, Any]]:
-    """Mechanical Pass-1 detection over timestamped cues.
-
-    cues: list of {"text", "start", "end"} in frames. Returns a list of Cuts.
-    """
-    cuts: List[Dict[str, Any]] = []
-    for i, cue in enumerate(cues):
-        text = (cue.get("text") or "").strip()
-        start, end = cue.get("start"), cue.get("end")
-
-        if _is_filler_only(text):
-            cuts.append(make_cut(
-                "filler", start, end, "lift", 0.8,
-                f"Filler-only cue: {text!r}", {"text": text},
-            ))
-
-        if i > 0:
-            prev_text = (cues[i - 1].get("text") or "").strip()
-            if _norm(prev_text) and _norm(text) == _norm(prev_text):
-                cuts.append(make_cut(
-                    "stammer", start, end, "lift", 0.6,
-                    f"Repeated line: {text!r}", {"text": text},
-                ))
-            prev_end = cues[i - 1].get("end")
-            if (prev_end is not None and start is not None
-                    and start - prev_end > long_pause_frames):
-                cuts.append(make_cut(
-                    "long_pause", prev_end, start, "lift", 0.5,
-                    f"Pause of {start - prev_end} frames before {text!r}",
-                    {"frames": start - prev_end},
-                ))
-    return cuts
-
-
-def build_cut_list(
-    cues: List[Dict[str, Any]],
-    *,
-    long_pause_frames: int = 48,
-) -> Dict[str, Any]:
-    """Run Pass-1 and wrap the result as a (dry-run) CutList."""
-    cuts = detect_cuts_pass1(cues, long_pause_frames=long_pause_frames)
-    return {
-        "cuts": cuts,
-        "cut_count": len(cuts),
-        "basis_cue_count": len(cues),
-        "pass": "mechanical",
-        "note": "Dry-run proposal. Review before applying; no edits were made.",
-    }

package/mcps/davinci-resolve-mcp/src/utils/dctl_templates.py

@@ -1,368 +0,0 @@
-#!/usr/bin/env python3
-"""Boilerplate generators for DCTL files (DaVinci Color Transform Language).
-
-DCTL is a C-like, GPU-compiled pixel shader language used by Resolve as
-programmable color transforms, the ResolveFX DCTL plugin, DCTL transitions,
-and custom ACES IDT/ODT transforms. See docs/notes/dctl-notes.md for the full
-spec; this module just emits ready-to-install source.
-
-After installing a DCTL, call project_settings(action='refresh_luts') to make
-Resolve re-scan its LUT directory. ACES DCTLs are scanned only at startup.
-"""
-
-from typing import Any, Dict, List, Optional
-
-
-def header(name: str, kind: str) -> str:
-    """Marker comment used by the dctl tool's `list` action."""
-    return (
-        f"// @mcp-dctl name={name} kind={kind}\n"
-        "// Generated by davinci-resolve-mcp. The marker above only affects\n"
-        "// how `dctl list` reports this file.\n\n"
-    )
-
-
-# UI-parameter type → pretty-printed DCTL keyword.
-DCTL_UI_TYPES = {
-    "float": "DCTLUI_SLIDER_FLOAT",
-    "int": "DCTLUI_SLIDER_INT",
-    "value": "DCTLUI_VALUE_BOX",
-    "checkbox": "DCTLUI_CHECK_BOX",
-    "combo": "DCTLUI_COMBO_BOX",
-    "color": "DCTLUI_COLOR_PICKER",
-}
-
-
-def _render_ui_params(params: List[Dict[str, Any]]) -> str:
-    """Render a list of param dicts as a `DEFINE_UI_PARAMS` block per param.
-
-    Each dict supports:
-        name   (required) — identifier referenced inside transform()
-        label  (optional, defaults to name)
-        type   'float'|'int'|'value'|'checkbox'|'combo'|'color' (default 'float')
-        default, min, max, step  numeric defaults appropriate per type
-        tooltip  optional string
-    """
-    if not params:
-        return ""
-    lines = []
-    for prm in params:
-        pname = prm["name"]
-        label = prm.get("label", pname)
-        ptype = prm.get("type", "float")
-        if ptype not in DCTL_UI_TYPES:
-            raise ValueError(f"Invalid DCTL UI type '{ptype}'. "
-                             f"Valid: {sorted(DCTL_UI_TYPES.keys())}")
-        kw = DCTL_UI_TYPES[ptype]
-
-        if ptype in ("float", "int", "value"):
-            default = prm.get("default", 1.0)
-            pmin = prm.get("min", 0.0)
-            pmax = prm.get("max", 4.0)
-            step = prm.get("step", 0.01 if ptype != "int" else 1)
-            lines.append(
-                f"DEFINE_UI_PARAMS({pname}, {label}, {kw}, "
-                f"{default}, {pmin}, {pmax}, {step})"
-            )
-        elif ptype == "checkbox":
-            default = int(bool(prm.get("default", 0)))
-            lines.append(f"DEFINE_UI_PARAMS({pname}, {label}, {kw}, {default})")
-        elif ptype == "combo":
-            default = prm.get("default", 0)
-            options = prm.get("options", [])
-            opts = ", ".join(options)
-            lines.append(f"DEFINE_UI_PARAMS({pname}, {label}, {kw}, {default}, {opts})")
-        elif ptype == "color":
-            r = prm.get("r", 1.0)
-            g = prm.get("g", 1.0)
-            b = prm.get("b", 1.0)
-            lines.append(f"DEFINE_UI_PARAMS({pname}, {label}, {kw}, {r}, {g}, {b})")
-
-        if "tooltip" in prm:
-            lines.append(f'DEFINE_UI_TOOLTIP({pname}, "{prm["tooltip"]}")')
-    return "\n".join(lines) + "\n\n"
-
-
-def transform(name: str, options: Optional[Dict[str, Any]] = None) -> str:
-    """Per-pixel transform DCTL with optional UI sliders.
-
-    options:
-        params: list of UI param dicts (see _render_ui_params).
-                Default exposes a single Gain slider.
-        body:   transform body. Receives p_R, p_G, p_B and any UI params by
-                their declared name. Default: applies Gain uniformly.
-
-    The generated DCTL uses the float3 entry point (no alpha).
-    """
-    options = options or {}
-    params = options.get("params")
-    if params is None:
-        params = [{"name": "p_Gain", "label": "Gain", "type": "float",
-                   "default": 1.0, "min": 0.0, "max": 4.0, "step": 0.01}]
-    body = options.get("body") or (
-        "    return make_float3(p_R * p_Gain, p_G * p_Gain, p_B * p_Gain);"
-    )
-    ui_block = _render_ui_params(params)
-    return header(name, "transform") + f'''{ui_block}__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y,
-                              float p_R, float p_G, float p_B)
-{{
-{body}
-}}
-'''
-
-
-def transform_alpha(name: str, options: Optional[Dict[str, Any]] = None) -> str:
-    """Per-pixel transform DCTL with alpha (Resolve 19.1+).
-
-    options:
-        params:     list of UI param dicts (default: empty)
-        alpha_mode: 'straight' | 'premultiply' (default 'straight')
-        body:       transform body returning a float4. Default passes through.
-
-    Sets the appropriate `DEFINE_DCTL_ALPHA_MODE_*` tag.
-    """
-    options = options or {}
-    params = options.get("params") or []
-    alpha_mode = options.get("alpha_mode", "straight")
-    if alpha_mode not in ("straight", "premultiply"):
-        raise ValueError(f"Invalid alpha_mode '{alpha_mode}'. "
-                         "Valid: straight, premultiply")
-    mode_tag = ("DEFINE_DCTL_ALPHA_MODE_STRAIGHT"
-                if alpha_mode == "straight"
-                else "DEFINE_DCTL_ALPHA_MODE_PREMULTIPLY")
-    body = options.get("body") or (
-        "    return make_float4(p_R, p_G, p_B, p_A);"
-    )
-    ui_block = _render_ui_params(params)
-    return header(name, "transform_alpha") + f'''{ui_block}{mode_tag}
-
-__DEVICE__ float4 transform(int p_Width, int p_Height, int p_X, int p_Y,
-                              float p_R, float p_G, float p_B, float p_A)
-{{
-{body}
-}}
-'''
-
-
-def transition(name: str, options: Optional[Dict[str, Any]] = None) -> str:
-    """DCTL transition. Blends From and To clips using TRANSITION_PROGRESS.
-
-    options:
-        body: transition body returning a float4. Default linear cross-dissolve.
-
-    The generated DCTL uses texture-based From and To inputs and reads the
-    global TRANSITION_PROGRESS value (0.0 to 1.0).
-    """
-    options = options or {}
-    body = options.get("body") or '''    float fromR = _tex2D(p_FromTexR, p_X, p_Y);
-    float fromG = _tex2D(p_FromTexG, p_X, p_Y);
-    float fromB = _tex2D(p_FromTexB, p_X, p_Y);
-    float fromA = _tex2D(p_FromTexA, p_X, p_Y);
-    float toR = _tex2D(p_ToTexR, p_X, p_Y);
-    float toG = _tex2D(p_ToTexG, p_X, p_Y);
-    float toB = _tex2D(p_ToTexB, p_X, p_Y);
-    float toA = _tex2D(p_ToTexA, p_X, p_Y);
-
-    float t = TRANSITION_PROGRESS;
-    return make_float4(
-        fromR * (1.0f - t) + toR * t,
-        fromG * (1.0f - t) + toG * t,
-        fromB * (1.0f - t) + toB * t,
-        fromA * (1.0f - t) + toA * t);'''
-    return header(name, "transition") + f'''__DEVICE__ float4 transition(
-    int p_Width, int p_Height, int p_X, int p_Y,
-    __TEXTURE__ p_FromTexR, __TEXTURE__ p_FromTexG,
-    __TEXTURE__ p_FromTexB, __TEXTURE__ p_FromTexA,
-    __TEXTURE__ p_ToTexR, __TEXTURE__ p_ToTexG,
-    __TEXTURE__ p_ToTexB, __TEXTURE__ p_ToTexA)
-{{
-{body}
-}}
-'''
-
-
-def matrix(name: str, options: Optional[Dict[str, Any]] = None) -> str:
-    """3x3 color matrix transform.
-
-    options:
-        matrix: nested 3x3 list of floats. Default = identity.
-                Order: [[Rr, Rg, Rb], [Gr, Gg, Gb], [Br, Bg, Bb]]
-
-    Embeds the matrix as constants and applies it as `out = M * in`.
-    """
-    options = options or {}
-    m = options.get("matrix") or [[1.0, 0.0, 0.0],
-                                  [0.0, 1.0, 0.0],
-                                  [0.0, 0.0, 1.0]]
-    if (not isinstance(m, list) or len(m) != 3
-            or any(not isinstance(row, list) or len(row) != 3 for row in m)):
-        raise ValueError("matrix option must be a 3x3 nested list")
-    rows = ",\n        ".join(
-        f"{{{', '.join(_f(x) for x in row)}}}" for row in m
-    )
-    return header(name, "matrix") + f'''__CONSTANT__ float M[3][3] = {{
-        {rows}
-}};
-
-__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y,
-                              float p_R, float p_G, float p_B)
-{{
-    float r = M[0][0] * p_R + M[0][1] * p_G + M[0][2] * p_B;
-    float g = M[1][0] * p_R + M[1][1] * p_G + M[1][2] * p_B;
-    float b = M[2][0] * p_R + M[2][1] * p_G + M[2][2] * p_B;
-    return make_float3(r, g, b);
-}}
-'''
-
-
-def lut_apply(name: str, options: Optional[Dict[str, Any]] = None) -> str:
-    """DCTL that loads an external .cube LUT and applies it.
-
-    options:
-        lut_path: relative or absolute path to a .cube file. The path is
-                  resolved relative to the .dctl file's location.
-                  Default: 'YourLut.cube' (placeholder — user must edit).
-        params:   optional UI param list (mix amount, etc.).
-        body:     transform body. Default applies the LUT directly.
-
-    Reference: docs/notes/dctl-notes.md → "LUTs Inside DCTL". Use APPLY_LUT(r, g, b,
-    name) to apply either an external cube or an inline DEFINE_CUBE_LUT.
-    """
-    options = options or {}
-    lut_path = options.get("lut_path", "YourLut.cube")
-    params = options.get("params") or [
-        {"name": "p_Mix", "label": "Mix", "type": "float",
-         "default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}
-    ]
-    body = options.get("body") or '''    float lutR = p_R, lutG = p_G, lutB = p_B;
-    APPLY_LUT(lutR, lutG, lutB, ExternalLut);
-    return make_float3(
-        p_R + (lutR - p_R) * p_Mix,
-        p_G + (lutG - p_G) * p_Mix,
-        p_B + (lutB - p_B) * p_Mix);'''
-    ui_block = _render_ui_params(params)
-    return header(name, "lut_apply") + f'''DEFINE_LUT(ExternalLut, {lut_path})
-
-{ui_block}__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y,
-                              float p_R, float p_G, float p_B)
-{{
-{body}
-}}
-'''
-
-
-def aces_idt(name: str, options: Optional[Dict[str, Any]] = None) -> str:
-    """ACES Input Device Transform. Installs to ACES Transforms/IDT/.
-
-    options:
-        parametric: bool — if true, emits the V1 parametric template stub
-                    (DEFINE_ACES_PARAM). If false, non-parametric stub.
-                    Default false.
-        body:       transform body. Default passes through.
-
-    ACES DCTLs are scanned at Resolve startup, NOT through RefreshLUTList().
-    Install requires a Resolve restart. See docs/notes/dctl-notes.md → "DCTL And ACES".
-    """
-    options = options or {}
-    parametric = bool(options.get("parametric", False))
-    body = options.get("body") or (
-        "    return make_float3(p_R, p_G, p_B);"
-    )
-    aces_def = (
-        "DEFINE_ACES_PARAM(IS_PARAMETRIC_ACES_TRANSFORM: 1)"
-        if parametric
-        else "DEFINE_ACES_PARAM(IS_PARAMETRIC_ACES_TRANSFORM: 0)"
-    )
-    return header(name, "aces_idt") + f'''{aces_def}
-
-__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y,
-                              float p_R, float p_G, float p_B)
-{{
-{body}
-}}
-'''
-
-
-def aces_odt(name: str, options: Optional[Dict[str, Any]] = None) -> str:
-    """ACES Output Device Transform. Installs to ACES Transforms/ODT/.
-
-    Identical structure to aces_idt; the directory placement is what tells
-    Resolve which side of the pipeline this transform belongs to.
-    """
-    options = options or {}
-    parametric = bool(options.get("parametric", False))
-    body = options.get("body") or (
-        "    return make_float3(p_R, p_G, p_B);"
-    )
-    aces_def = (
-        "DEFINE_ACES_PARAM(IS_PARAMETRIC_ACES_TRANSFORM: 1)"
-        if parametric
-        else "DEFINE_ACES_PARAM(IS_PARAMETRIC_ACES_TRANSFORM: 0)"
-    )
-    return header(name, "aces_odt") + f'''{aces_def}
-
-__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y,
-                              float p_R, float p_G, float p_B)
-{{
-{body}
-}}
-'''
-
-
-def kernel(name: str, options: Optional[Dict[str, Any]] = None) -> str:
-    """Bare-bones DCTL with structured TODO comments.
-
-    Useful when the user wants to write the DCTL by hand but wants the
-    boilerplate (header, signature, alpha note) generated for them.
-    """
-    options = options or {}
-    return header(name, "kernel") + f'''// TODO: Replace with your transform implementation.
-// Reference: docs/notes/dctl-notes.md
-//
-// Useful globals:
-//   __RESOLVE_VER_MAJOR__, __RESOLVE_VER_MINOR__
-//   DEVICE_IS_CUDA / DEVICE_IS_OPENCL / DEVICE_IS_METAL
-//   TIMELINE_FRAME_INDEX  (defaults to 1 when used as a LUT)
-//
-// Float literals must use the `f` suffix: 1.2f not 1.2
-
-__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y,
-                              float p_R, float p_G, float p_B)
-{{
-    // TODO
-    return make_float3(p_R, p_G, p_B);
-}}
-'''
-
-
-def _f(x: float) -> str:
-    """Format a float with the trailing 'f' suffix DCTL requires."""
-    s = f"{float(x):.6g}"
-    if "." not in s and "e" not in s and "n" not in s:
-        s += ".0"
-    return s + "f"
-
-
-TEMPLATES = {
-    "transform": transform,
-    "transform_alpha": transform_alpha,
-    "transition": transition,
-    "matrix": matrix,
-    "kernel": kernel,
-    "lut_apply": lut_apply,
-    "aces_idt": aces_idt,
-    "aces_odt": aces_odt,
-}
-
-# Maps each template kind to the install category, which the dctl tool uses
-# to pick the right install directory (regular LUT vs. ACES Transforms).
-KIND_CATEGORY = {
-    "transform": "lut",
-    "transform_alpha": "lut",
-    "transition": "lut",
-    "matrix": "lut",
-    "kernel": "lut",
-    "lut_apply": "lut",
-    "aces_idt": "aces_idt",
-    "aces_odt": "aces_odt",
-}