livepilot 1.23.6 → 1.25.0

package/mcp_server/composer/fast/tier_classification.py

@@ -0,0 +1,159 @@
+"""Tier classification for instruments — used by fast-mode brief hunt-order.
+
+The framework provides VOCABULARY (descriptive). The LLM provides FORM (creative).
+For instrument candidates: Tier-A and Tier-B are safe to return in briefs.
+Tier-C bare URIs MUST NEVER be returned — the brief substitutes a curated preset
+or omits that synth entirely.
+
+Tier table (BINDING):
+  A_curated_preset — .adg / .adv from sounds/ folder. Loaded with character.
+  A_drum_sample    — raw sample (.aif/.wav) from drums/ folder. load_browser_item
+                     auto-wraps in Simpler with drum-role defaults.
+  B_drum_synth     — drum-specific synth (DS Kick etc). Default patch IS the drum.
+  B_audible_default — generic melodic synth (Operator, Wavetable etc).
+                      Default patch is "generic AI synth" — only return as fallback
+                      when sounds/ returns nothing for a melodic role.
+  C_needs_preset   — empty container (Drum Sampler, Emit etc). NEVER return.
+
+Legacy tier value "A_sample_ready" is accepted in VALID_BRIEF_TIERS so old
+tests still pass; new candidates use the specific A_* values.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+# ── Tier VALUE constants (used as the `tier` field in brief candidates) ──
+
+TIER_A_CURATED_PRESET = "A_curated_preset"
+TIER_A_DRUM_SAMPLE = "A_drum_sample"
+TIER_B_DRUM_SYNTH = "B_drum_synth"
+TIER_B_AUDIBLE_DEFAULT_VALUE = "B_audible_default"
+TIER_C_NEEDS_PRESET_VALUE = "C_needs_preset"
+
+# Tiers that are valid in brief output (Tier-C is NEVER valid)
+VALID_BRIEF_TIERS = frozenset({
+    TIER_A_CURATED_PRESET,
+    TIER_A_DRUM_SAMPLE,
+    TIER_B_DRUM_SYNTH,
+    TIER_B_AUDIBLE_DEFAULT_VALUE,
+    # Legacy alias — kept so old briefs and tests still work
+    "A_sample_ready",
+    # Legacy alias — "B_audible_default" is also the old tier value and is valid
+    "B_audible_default",
+})
+
+# Role sets
+DRUM_ROLES = frozenset({"kick", "snare", "hat", "perc", "clap", "tom", "drum"})
+MELODIC_ROLES = frozenset({"bass", "lead", "pad", "atmos", "vox", "fx", "texture"})
+
+
+# ── Frozensets of instrument names (used for name-based classification) ──
+
+# Drum-specific synths — purpose-built drum sound generators.
+# Their default patches ARE the intended drum sound (unlike generic melodic
+# synths whose defaults are "generic AI synth").
+# Allowed in drum-role briefs as Tier-B without curated presets.
+DRUM_SPECIFIC_SYNTHS: frozenset[str] = frozenset({
+    "DS Kick",
+    "DS Snare",
+    "DS Hi-Hat",
+    "DS Clap",
+    "DS Cymbal",
+    "DS Tom",
+    "DS Sampler",
+    "DS Drum Bus",
+})
+
+# Melodic synths with audible defaults — "generic AI synth" risk.
+# Renamed from TIER_B_AUDIBLE_DEFAULT to MELODIC_AUDIBLE_DEFAULTS to
+# disambiguate from the tier VALUE string TIER_B_AUDIBLE_DEFAULT_VALUE.
+# The old name TIER_B_AUDIBLE_DEFAULT is kept as an alias for backward compat.
+MELODIC_AUDIBLE_DEFAULTS: frozenset[str] = frozenset({
+    "Operator",
+    "Wavetable",
+    "Drift",
+    "Analog",
+    "Bass",
+    "Electric",
+    "Tension",
+    "Collision",
+    "Meld",
+})
+
+# Backward-compat alias (old tests and callers use this name)
+TIER_B_AUDIBLE_DEFAULT = MELODIC_AUDIBLE_DEFAULTS
+
+# Containers + programming-required synths — NEVER return bare URIs.
+# Renamed from TIER_C_NEEDS_PRESET to CONTAINERS_NEEDING_PRESETS to
+# disambiguate from the tier VALUE string TIER_C_NEEDS_PRESET_VALUE.
+# The old name TIER_C_NEEDS_PRESET is kept as an alias for backward compat.
+CONTAINERS_NEEDING_PRESETS: frozenset[str] = frozenset({
+    "Drum Sampler",
+    "Drum Rack",
+    "DrumGroup",      # internal alias for Drum Rack
+    "Simpler",
+    "Sampler",
+    "Impulse",
+    "Emit",
+    "Vector FM",
+    "Vector Grain",
+    "Granulator III",
+    "Granulator II",  # legacy
+    "Instrument Rack",
+    "Looper",
+    "External Instrument",
+})
+
+# Backward-compat alias
+TIER_C_NEEDS_PRESET = CONTAINERS_NEEDING_PRESETS
+
+# Combined lookup: name → tier string
+# Drum-specific synths → "B_drum_synth"; melodic audible defaults → "B_audible_default";
+# containers → "C_needs_preset". Unknown instruments return None.
+TIER_CLASSIFICATION: dict[str, str] = {
+    name: "B_drum_synth" for name in DRUM_SPECIFIC_SYNTHS
+} | {
+    name: "B_audible_default" for name in MELODIC_AUDIBLE_DEFAULTS
+} | {
+    name: "C_needs_preset" for name in CONTAINERS_NEEDING_PRESETS
+}
+
+
+def classify_instrument(name: str) -> Optional[str]:
+    """Classify an instrument by name.
+
+    Returns one of:
+      "B_drum_synth"      — drum-specific synth, safe for drum roles bare
+      "B_audible_default" — generic melodic synth, only as fallback
+      "C_needs_preset"    — container, NEVER return bare
+      None                — unknown instrument
+    """
+    return TIER_CLASSIFICATION.get(name)
+
+
+def is_drum_specific_synth(name: str) -> bool:
+    """True if `name` is a drum-specific synth — safe to return bare for drum roles."""
+    return name in DRUM_SPECIFIC_SYNTHS
+
+
+# Search terms for hunting curated chains in sounds/ and drums/ per role.
+# Used by build_creative_brief to populate instruments_by_role.
+ROLE_SEARCH_TERMS: dict[str, dict[str, Optional[str]]] = {
+    # drum roles — search drums/ first, sounds/ second
+    "kick":    {"sounds_term": "kick",       "drums_term": "kick"},
+    "snare":   {"sounds_term": "snare",      "drums_term": "snare"},
+    "hat":     {"sounds_term": "hihat",      "drums_term": "hihat"},
+    "perc":    {"sounds_term": "percussion", "drums_term": "perc"},
+    "clap":    {"sounds_term": "clap",       "drums_term": "clap"},
+    "tom":     {"sounds_term": "tom",        "drums_term": "tom"},
+    # melodic roles — search sounds/ for curated presets
+    "bass":    {"sounds_term": "bass",    "drums_term": None},
+    "lead":    {"sounds_term": "lead",    "drums_term": None},
+    "pad":     {"sounds_term": "pad",     "drums_term": None},
+    "atmos":   {"sounds_term": "ambient", "drums_term": None},
+    "vox":     {"sounds_term": "vocal",   "drums_term": None},
+    "fx":      {"sounds_term": "fx",      "drums_term": None},
+    "texture": {"sounds_term": "texture", "drums_term": None},
+}

package/mcp_server/composer/framework/applier.py

@@ -0,0 +1,179 @@
+"""Applier — shared Phase-3 executor for fast / full / develop compose modes.
+
+Concentrates pre-flight (analyzer load + bridge connect + handshake retry)
+and post-flight (monitoring state + back_to_arranger) so fixes for
+BUG-FULL-MODE-14 (bridge race) and BUG-FULL-MODE-17 (manual arm required)
+land once across all three modes instead of three times.
+
+Functions are dependency-injected (not imported directly) so unit tests can
+mock them without monkey-patching.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Awaitable, Callable, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# Type aliases
+AsyncCtxFn = Callable[[Any], Awaitable[Any]]
+AsyncTrackFn = Callable[..., Awaitable[Any]]
+
+
+class Applier:
+    """Shared pre-flight + apply + post-flight skeleton for compose modes.
+
+    v1.24 Phase 1: pre-flight + post-flight only. The `run()` method (full
+    plan execution) stays a stub; each mode's apply.py wires its own
+    plan-execution loop using `Applier.preflight()` and `Applier.postflight()`
+    around it.
+
+    Future phases may extend this with a unified plan-walker.
+    """
+
+    def __init__(
+        self,
+        *,
+        ensure_analyzer_fn: AsyncCtxFn,
+        reconnect_bridge_fn: AsyncCtxFn,
+        bridge_ping_fn: AsyncCtxFn,
+        set_track_input_monitoring_fn: Optional[AsyncTrackFn] = None,
+        back_to_arranger_fn: Optional[AsyncCtxFn] = None,
+        handshake_max_attempts: int = 3,
+        handshake_gap_seconds: float = 0.2,
+    ):
+        self._ensure_analyzer_fn = ensure_analyzer_fn
+        self._reconnect_bridge_fn = reconnect_bridge_fn
+        self._bridge_ping_fn = bridge_ping_fn
+        self._set_track_input_monitoring_fn = set_track_input_monitoring_fn
+        self._back_to_arranger_fn = back_to_arranger_fn
+        self._handshake_max_attempts = handshake_max_attempts
+        self._handshake_gap_seconds = handshake_gap_seconds
+
+    # ── pre-flight ──────────────────────────────────────────────────
+
+    async def preflight(self, ctx: Any) -> dict:
+        """Load analyzer, connect bridge, handshake until ping succeeds.
+
+        Fixes BUG-FULL-MODE-14: the previous code returned success on
+        bridge.connect() but the M4L JS listener takes 100-500ms to bind
+        the UDP socket. Without the handshake retry loop, the next
+        bridge-using call (load_sample_to_simpler etc.) fails with
+        "UDP bridge is not connected".
+
+        Returns dict with keys: analyzer_status, bridge_connected,
+        handshake_attempts, and optionally handshake_error if all
+        retries failed.
+        """
+        analyzer_result = await self._ensure_analyzer_fn(ctx)
+        analyzer_status = (
+            analyzer_result.get("status", "unknown")
+            if isinstance(analyzer_result, dict)
+            else "unknown"
+        )
+
+        bridge_result = await self._reconnect_bridge_fn(ctx)
+        bridge_connected_initial = (
+            bridge_result.get("connected", False)
+            if isinstance(bridge_result, dict)
+            else False
+        )
+
+        handshake_attempts = 0
+        handshake_error: Optional[str] = None
+        bridge_ready = False
+
+        if bridge_connected_initial:
+            for attempt in range(1, self._handshake_max_attempts + 1):
+                handshake_attempts = attempt
+                try:
+                    await self._bridge_ping_fn(ctx)
+                    bridge_ready = True
+                    break
+                except Exception as exc:
+                    handshake_error = str(exc)
+                    logger.debug(
+                        "Applier preflight handshake attempt %d failed: %s",
+                        attempt,
+                        exc,
+                    )
+                    if attempt < self._handshake_max_attempts:
+                        await asyncio.sleep(self._handshake_gap_seconds)
+
+        result = {
+            "analyzer_status": analyzer_status,
+            "bridge_connected": bridge_ready,
+            "handshake_attempts": handshake_attempts,
+        }
+        if not bridge_ready and handshake_error is not None:
+            result["handshake_error"] = handshake_error
+        return result
+
+    # ── post-flight ─────────────────────────────────────────────────
+
+    async def postflight(
+        self,
+        ctx: Any,
+        applied_track_indices: list[int],
+    ) -> dict:
+        """Set monitoring=Auto on each newly-created track, then back_to_arranger.
+
+        BUG-FIX (post-Phase-4-Task-4 live test): the original BUG-FULL-MODE-17
+        fix set monitoring to state=0 ("In"), which is WRONG. State codes:
+            0 = In   (always pass input through — leaves track "hot")
+            1 = Auto (monitor when armed + recording — DEFAULT for new tracks)
+            2 = Off  (never monitor)
+
+        New tracks default to Auto (1) and arrangement clips already play
+        correctly with Auto. The actual fix for "manual arm required" is
+        back_to_arranger alone — clearing the session-vs-arrangement
+        override flag. We set state=Auto here defensively in case any
+        other code path moved monitoring away from default.
+
+        applied_track_indices: list of track indices that were created
+        during this apply pass. Empty list (e.g. develop mode writing
+        only session clips, no new tracks) skips the per-track step but
+        still calls back_to_arranger.
+        """
+        tracks_set = 0
+        if self._set_track_input_monitoring_fn is not None:
+            for track_index in applied_track_indices:
+                try:
+                    # state=1 (Auto) — the default for new tracks. NOT 0 (In).
+                    await self._set_track_input_monitoring_fn(
+                        ctx, track_index=track_index, state=1
+                    )
+                    tracks_set += 1
+                except Exception as exc:
+                    logger.warning(
+                        "Applier postflight set_monitoring failed for track %d: %s",
+                        track_index,
+                        exc,
+                    )
+
+        back_to_arranger_ok = False
+        if self._back_to_arranger_fn is not None:
+            try:
+                await self._back_to_arranger_fn(ctx)
+                back_to_arranger_ok = True
+            except Exception as exc:
+                logger.warning("Applier postflight back_to_arranger failed: %s", exc)
+
+        return {
+            "tracks_set": tracks_set,
+            "back_to_arranger": back_to_arranger_ok,
+        }
+
+    # ── stub run() — not used in v1.24 ──────────────────────────────
+
+    async def run(self, ctx: Any, plan: list) -> dict:
+        """Stub kept from Task 1 — full plan-walk implementation deferred.
+
+        Phase 1 only extracts pre/post-flight. Each mode's apply.py
+        continues to execute its own plan loop, just sandwiched by
+        ``preflight()`` and ``postflight()``.
+        """
+        return {"status": "stub"}

package/mcp_server/composer/framework/artist_loader.py

@@ -0,0 +1,63 @@
+"""Markdown parser for livepilot/skills/livepilot-core/references/artist-vocabularies.md."""
+
+from __future__ import annotations
+import re
+from pathlib import Path
+from typing import Optional
+
+
+_ARTIST_CACHE: Optional[dict[str, dict]] = None
+
+
+def _artist_md_path() -> Optional[Path]:
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        candidate = parent / "livepilot" / "skills" / "livepilot-core" / "references" / "artist-vocabularies.md"
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def _load_artist_md() -> dict[str, dict]:
+    """Parse artist entries. Existing pattern in develop/brief_builder.py:
+    `### Name` headers with body content."""
+    global _ARTIST_CACHE
+    if _ARTIST_CACHE is not None:
+        return _ARTIST_CACHE
+    path = _artist_md_path()
+    if path is None:
+        _ARTIST_CACHE = {}
+        return _ARTIST_CACHE
+    text = path.read_text(encoding="utf-8")
+
+    artists: dict[str, dict] = {}
+    sections = re.split(r"^###\s+(.+?)\s*$", text, flags=re.MULTILINE)
+    for i in range(1, len(sections), 2):
+        name = sections[i].strip()
+        if not name or "Vocabulary" in name or "How to" in name:
+            continue
+        body = sections[i + 1] if i + 1 < len(sections) else ""
+        # Strip parenthetical aliases for canonical key: "Aphex Twin (Richard D. James)" → "Aphex Twin"
+        primary = re.sub(r"\s*\(.*?\)\s*$", "", name).strip()
+        if primary:
+            artists[primary] = {"name": primary, "raw_md": body.strip()[:2000]}
+    _ARTIST_CACHE = artists
+    return _ARTIST_CACHE
+
+
+def load_artist_context(artist_names: list[str]) -> dict[str, dict]:
+    """Load context for the given artist names.
+
+    artist_names: list of names (case-insensitive matched against parser keys)
+    Returns: {artist_name: {raw_md: ..., ...}, ...}
+    """
+    if not artist_names:
+        return {}
+    parsed = _load_artist_md()
+    result = {}
+    parsed_lower = {k.lower(): k for k in parsed.keys()}
+    for name in artist_names:
+        canonical = parsed_lower.get(name.lower())
+        if canonical:
+            result[canonical] = parsed[canonical]
+    return result