livepilot 1.9.24 → 1.10.0

package/mcp_server/runtime/capability_probe.py

@@ -34,6 +34,23 @@ def probe_capabilities(
         "detail": "TCP 9878 connection active" if ableton_ok else "Not connected",
     }
 
+    # 1b. Live version capabilities
+    live_version_str = "12.0.0"
+    if ableton_ok:
+        try:
+            info = ableton.send_command("get_session_info")
+            live_version_str = info.get("live_version", "12.0.0")
+        except Exception:
+            pass
+    from .live_version import LiveVersionCapabilities
+    version_caps = LiveVersionCapabilities.from_version_string(live_version_str)
+    report["live_version"] = {
+        "status": "ok",
+        "version": live_version_str,
+        "capability_tier": version_caps.capability_tier,
+        "features": version_caps.to_dict(),
+    }
+
     # 2. Remote Script parity
     from .remote_commands import REMOTE_COMMANDS
     report["remote_script"] = {
@@ -45,8 +62,10 @@ def probe_capabilities(
     # 3. M4L bridge
     bridge_ok = False
     if ctx is not None:
-        bridge = getattr(ctx, "lifespan_context", {}).get("m4l_bridge") if hasattr(ctx, "lifespan_context") else None
-        bridge_ok = bridge is not None
+        lifespan_context = getattr(ctx, "lifespan_context", {}) if hasattr(ctx, "lifespan_context") else {}
+        bridge = lifespan_context.get("m4l")
+        spectral = lifespan_context.get("spectral")
+        bridge_ok = bridge is not None and spectral is not None and getattr(spectral, "is_connected", False)
     report["m4l_bridge"] = {
         "status": "ok" if bridge_ok else "unavailable",
         "detail": "UDP 9880 / OSC 9881 active" if bridge_ok else "Not connected — 30 analyzer tools unavailable",

package/mcp_server/runtime/execution_router.py

@@ -29,6 +29,10 @@ MCP_TOOLS: frozenset[str] = frozenset({
     "get_emotional_arc",
     "capture_audio",
     "get_motif_graph",
+    # Device Forge tools (MCP-only, no TCP handler)
+    "generate_m4l_effect",
+    "install_m4l_device",
+    "list_genexpr_templates",
 })
 
 

package/mcp_server/runtime/live_version.py

@@ -0,0 +1,102 @@
+"""MCP-side Live version capabilities model.
+
+Pure data model — no I/O. Parses version info from get_session_info
+responses and exposes feature flags for tool routing.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class LiveVersionCapabilities:
+    """Feature availability based on detected Live version."""
+
+    major: int = 12
+    minor: int = 0
+    patch: int = 0
+
+    @classmethod
+    def from_version_string(cls, version_str: str) -> LiveVersionCapabilities:
+        """Parse '12.3.6' into a capabilities instance."""
+        parts = version_str.split(".")
+        major = int(parts[0]) if len(parts) > 0 else 12
+        minor = int(parts[1]) if len(parts) > 1 else 0
+        patch = int(parts[2]) if len(parts) > 2 else 0
+        return cls(major=major, minor=minor, patch=patch)
+
+    @classmethod
+    def from_session_info(cls, session_info: dict) -> LiveVersionCapabilities:
+        """Extract version from get_session_info response.
+
+        Looks for 'live_version' field. Falls back to 12.0.0 if absent
+        (pre-upgrade Remote Script).
+        """
+        version_str = session_info.get("live_version", "12.0.0")
+        return cls.from_version_string(version_str)
+
+    @property
+    def _version_tuple(self) -> tuple[int, int, int]:
+        return (self.major, self.minor, self.patch)
+
+    # ── Feature flags ──────────────────────────────────────────────
+
+    @property
+    def has_native_arrangement_clips(self) -> bool:
+        """Track.create_midi_clip(start, length) — 12.1.10+"""
+        return self._version_tuple >= (12, 1, 10)
+
+    @property
+    def has_display_value(self) -> bool:
+        """DeviceParameter.display_value — 12.2+"""
+        return self._version_tuple >= (12, 2, 0)
+
+    @property
+    def has_insert_device(self) -> bool:
+        """Track.insert_device(name, index?) — 12.3+"""
+        return self._version_tuple >= (12, 3, 0)
+
+    @property
+    def has_drum_rack_construction(self) -> bool:
+        """insert_chain + DrumChain.in_note — 12.3+"""
+        return self._version_tuple >= (12, 3, 0)
+
+    @property
+    def has_take_lanes(self) -> bool:
+        """Take Lanes API — 12.2+"""
+        return self._version_tuple >= (12, 2, 0)
+
+    @property
+    def has_stem_separation(self) -> bool:
+        """Stem separation via MFL — 12.3+"""
+        return self._version_tuple >= (12, 3, 0)
+
+    @property
+    def has_replace_sample_native(self) -> bool:
+        """SimplerDevice.replace_sample(path) — 12.4+"""
+        return self._version_tuple >= (12, 4, 0)
+
+    @property
+    def capability_tier(self) -> str:
+        """Human-readable tier: core | enhanced_arrangement | full_intelligence."""
+        if self._version_tuple >= (12, 3, 0):
+            return "full_intelligence"
+        elif self._version_tuple >= (12, 1, 10):
+            return "enhanced_arrangement"
+        else:
+            return "core"
+
+    def to_dict(self) -> dict:
+        """Serialize for API responses and capability probes."""
+        return {
+            "version": f"{self.major}.{self.minor}.{self.patch}",
+            "capability_tier": self.capability_tier,
+            "native_arrangement_clips": self.has_native_arrangement_clips,
+            "display_value": self.has_display_value,
+            "insert_device": self.has_insert_device,
+            "drum_rack_construction": self.has_drum_rack_construction,
+            "take_lanes": self.has_take_lanes,
+            "stem_separation": self.has_stem_separation,
+            "replace_sample_native": self.has_replace_sample_native,
+        }

package/mcp_server/runtime/remote_commands.py

@@ -38,18 +38,23 @@ REMOTE_COMMANDS: frozenset[str] = frozenset({
     "fire_scene", "set_scene_name", "set_scene_color", "set_scene_tempo",
     "get_scene_matrix", "fire_scene_clips", "stop_all_clips",
     "get_playing_clips",
-    # devices (12)
+    # devices (15)
     "get_device_info", "get_device_parameters", "set_device_parameter",
     "batch_set_parameters", "toggle_device", "delete_device",
     "move_device", "load_device_by_uri", "find_and_load_device",
     "set_simpler_playback_mode", "get_rack_chains", "set_chain_volume",
+    "insert_device",           # 12.3+ native device insertion
+    "insert_rack_chain",       # 12.3+ rack chain insertion
+    "set_drum_chain_note",     # 12.3+ drum chain note assignment
     # clip_automation (3)
     "get_clip_automation", "set_clip_automation", "clear_clip_automation",
-    # browser (5)
+    # browser (6)
     "get_browser_tree", "get_browser_items", "search_browser",
     "load_browser_item", "get_device_presets",
-    # arrangement (19)
+    "scan_browser_deep",       # Atlas deep scan — returns full category tree
+    # arrangement (21)
     "get_arrangement_clips", "create_arrangement_clip",
+    "create_native_arrangement_clip",
     "add_arrangement_notes", "get_arrangement_notes",
     "remove_arrangement_notes", "remove_arrangement_notes_by_id",
     "modify_arrangement_notes", "duplicate_arrangement_notes",
@@ -57,7 +62,7 @@ REMOTE_COMMANDS: frozenset[str] = frozenset({
     "set_arrangement_clip_name", "jump_to_time",
     "capture_midi", "start_recording", "stop_recording",
     "get_cue_points", "jump_to_cue", "toggle_cue_point",
-    "back_to_arranger",
+    "back_to_arranger", "force_arrangement",
     # diagnostics (1)
     "get_session_diagnostics",
     # ping (built-in)

package/mcp_server/runtime/tools.py

@@ -94,14 +94,19 @@ def get_session_kernel(
 
     # Core: session info + capability state
     session_info = ableton.send_command("get_session_info")
+    session_ok = isinstance(session_info, dict) and "error" not in session_info
 
     analyzer_ok = False
+    analyzer_fresh = False
     if spectral is not None:
         analyzer_ok = spectral.is_connected
+        if analyzer_ok:
+            analyzer_fresh = spectral.get("spectrum") is not None
 
     state = build_capability_state(
-        session_ok=True,
+        session_ok=session_ok,
         analyzer_ok=analyzer_ok,
+        analyzer_fresh=analyzer_fresh,
         memory_ok=True,
     )
 
@@ -112,10 +117,19 @@ def get_session_kernel(
     session_mem = []
 
     try:
-        from .action_ledger import ActionLedger
-        ledger = ActionLedger.instance()
+        from .action_ledger import SessionLedger
+        ledger = ctx.lifespan_context.get("action_ledger")
+        if ledger is None:
+            ledger = SessionLedger()
+            ctx.lifespan_context["action_ledger"] = ledger
         if ledger:
-            ledger_summary = ledger.summary()
+            recent = ledger.get_recent_moves(limit=10)
+            ledger_summary = {
+                "total_moves": len(ledger._entries),
+                "memory_candidate_count": len(ledger.get_memory_candidates()),
+                "last_move": ledger.get_last_move().to_dict() if ledger.get_last_move() else None,
+                "recent_moves": [entry.to_dict() for entry in recent],
+            }
     except Exception:
         pass
 

package/mcp_server/sample_engine/__init__.py

@@ -0,0 +1 @@
+"""Sample Engine — intelligence layer for sample discovery, analysis, and manipulation."""

package/mcp_server/sample_engine/analyzer.py

@@ -0,0 +1,216 @@
+"""SampleAnalyzer — filename parsing, material classification, mode recommendation.
+
+Pure computation for the offline parts. Spectral analysis requires M4L bridge
+and is handled in tools.py which calls these functions + bridge data.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import Optional
+
+from .models import SampleProfile
+
+
+# ── Filename Metadata Parsing ───────────────────────────────────────
+
+# Key patterns: C, Cm, C#, C#m, Cb, Cbm, Csharp, Csharpmin, etc.
+_KEY_PATTERN = re.compile(
+    r'\b([A-G])([b#]|sharp|flat)?(m|min|minor|maj|major)?\b',
+    re.IGNORECASE,
+)
+
+# BPM patterns: 120bpm, 120_bpm, 120 BPM, or standalone 60-300 range
+_BPM_PATTERN = re.compile(
+    r'\b(\d{2,3})\s*(?:bpm)\b', re.IGNORECASE,
+)
+_BPM_STANDALONE = re.compile(
+    r'(?:^|[_\-\s])(\d{2,3})(?:[_\-\s]|$)',
+)
+
+_KEY_NORMALIZE = {
+    "sharp": "#", "flat": "b",
+    "min": "m", "minor": "m", "maj": "", "major": "",
+}
+
+
+def parse_filename_metadata(filename: str) -> dict:
+    """Extract key and BPM from a filename string.
+
+    Returns dict with 'key' (str|None) and 'bpm' (float|None).
+    """
+    stem = os.path.splitext(os.path.basename(filename))[0]
+    # Replace common separators with spaces for easier matching
+    normalized = stem.replace("-", " ").replace("_", " ")
+
+    key = _extract_key(normalized)
+    bpm = _extract_bpm(normalized)
+
+    return {"key": key, "bpm": bpm}
+
+
+def _extract_key(text: str) -> Optional[str]:
+    """Extract musical key from text."""
+    matches = list(_KEY_PATTERN.finditer(text))
+    for match in matches:
+        root = match.group(1).upper()
+        accidental = match.group(2) or ""
+        quality = match.group(3) or ""
+
+        # Normalize accidentals
+        accidental = _KEY_NORMALIZE.get(accidental.lower(), accidental)
+        quality = _KEY_NORMALIZE.get(quality.lower(), quality) if quality else ""
+
+        # Avoid false positives: single letters that are common words
+        full = root + accidental + quality
+        if len(full) == 1 and root in ("A", "B", "C", "D", "E", "F", "G"):
+            # Single letter — only accept if it looks like it's in a key context
+            # Check surrounding chars
+            start = match.start()
+            end = match.end()
+            before = text[start - 1] if start > 0 else " "
+            after = text[end] if end < len(text) else " "
+            if before.isalpha() or after.isalpha():
+                continue  # Part of a word, not a key
+        return full
+    return None
+
+
+def _extract_bpm(text: str) -> Optional[float]:
+    """Extract BPM from text."""
+    # Try explicit bpm markers first
+    match = _BPM_PATTERN.search(text)
+    if match:
+        bpm = float(match.group(1))
+        if 40 <= bpm <= 300:
+            return bpm
+
+    # Try standalone numbers in valid range
+    for match in _BPM_STANDALONE.finditer(text):
+        bpm = float(match.group(1))
+        if 60 <= bpm <= 250:
+            return bpm
+    return None
+
+
+# ── Material Classification ─────────────────────────────────────────
+
+_MATERIAL_KEYWORDS: dict[str, list[str]] = {
+    "vocal": ["vocal", "vox", "voice", "singer", "acapella", "spoken"],
+    "drum_loop": ["drum", "beat", "break", "breakbeat", "loop", "groove",
+                  "hihat", "hat", "ride", "cymbal", "perc", "percussion",
+                  "shaker", "tamb", "conga", "bongo", "top"],
+    "one_shot": ["kick", "snare", "clap", "snap", "tom", "rim", "hit",
+                 "oneshot", "one shot", "stab", "shot", "impact"],
+    "instrument_loop": ["guitar", "piano", "keys", "bass", "synth",
+                        "strings", "brass", "horn", "organ", "riff",
+                        "chord", "arp", "pluck"],
+    "texture": ["ambient", "pad", "drone", "atmosphere", "noise",
+                "texture", "wash", "evolving", "soundscape"],
+    "foley": ["foley", "field", "recording", "room", "nature",
+              "water", "metal", "wood", "glass", "paper"],
+    "fx": ["fx", "effect", "riser", "sweep", "whoosh", "boom",
+           "transition", "downlifter", "uplifter"],
+}
+
+
+def classify_material_from_name(name: str) -> str:
+    """Classify sample material type from filename/name keywords."""
+    lower = name.lower().replace("-", " ").replace("_", " ")
+
+    # Score each type by keyword matches
+    scores: dict[str, int] = {}
+    for material_type, keywords in _MATERIAL_KEYWORDS.items():
+        score = sum(1 for kw in keywords if kw in lower)
+        if score > 0:
+            scores[material_type] = score
+
+    if not scores:
+        return "unknown"
+
+    return max(scores, key=scores.get)
+
+
+# ── Simpler Mode Recommendation ────────────────────────────────────
+
+
+def suggest_simpler_mode(profile: SampleProfile) -> str:
+    """Recommend Simpler playback mode based on material analysis.
+
+    Returns: "classic", "one_shot", or "slice"
+    """
+    if profile.duration_seconds < 0.5 or profile.material_type == "one_shot":
+        return "classic"
+    if profile.material_type == "fx":
+        return "classic"
+    if profile.material_type in ("texture", "foley"):
+        return "classic"
+    if profile.material_type in ("drum_loop", "instrument_loop",
+                                  "vocal", "full_mix"):
+        return "slice"
+    # Unknown material with decent length — slice is more useful
+    if profile.duration_seconds > 2.0:
+        return "slice"
+    return "classic"
+
+
+def suggest_slice_method(profile: SampleProfile) -> str:
+    """Recommend slice-by method for Simpler's Slice mode."""
+    if profile.material_type == "drum_loop":
+        return "transient"
+    if profile.material_type == "instrument_loop":
+        return "beat"
+    if profile.material_type == "vocal":
+        return "region"
+    if profile.material_type == "full_mix":
+        return "beat"
+    return "transient"
+
+
+def suggest_warp_mode(profile: SampleProfile) -> str:
+    """Recommend Ableton warp mode for the sample material."""
+    mode_map = {
+        "drum_loop": "beats",
+        "one_shot": "complex",
+        "instrument_loop": "complex_pro",
+        "vocal": "complex_pro",
+        "texture": "texture",
+        "foley": "texture",
+        "fx": "complex",
+        "full_mix": "complex_pro",
+    }
+    return mode_map.get(profile.material_type, "complex")
+
+
+def build_profile_from_filename(
+    file_path: str,
+    source: str = "filesystem",
+    duration_seconds: float = 0.0,
+) -> SampleProfile:
+    """Build a SampleProfile from filename metadata only (no spectral analysis).
+
+    This is the fallback when M4L bridge is unavailable.
+    """
+    name = os.path.splitext(os.path.basename(file_path))[0]
+    metadata = parse_filename_metadata(file_path)
+    material = classify_material_from_name(name)
+
+    profile = SampleProfile(
+        source=source,
+        file_path=file_path,
+        name=name,
+        key=metadata.get("key"),
+        key_confidence=0.5 if metadata.get("key") else 0.0,
+        bpm=metadata.get("bpm"),
+        bpm_confidence=0.5 if metadata.get("bpm") else 0.0,
+        material_type=material,
+        material_confidence=0.4,  # filename-only is low confidence
+        duration_seconds=duration_seconds,
+    )
+
+    profile.suggested_mode = suggest_simpler_mode(profile)
+    profile.suggested_slice_by = suggest_slice_method(profile)
+    profile.suggested_warp_mode = suggest_warp_mode(profile)
+
+    return profile