livepilot 1.9.23 → 1.10.0

package/mcp_server/runtime/capability.py

@@ -0,0 +1,66 @@
+"""Capability and degradation reporting for advanced tools.
+
+Every advanced tool reports its operational state so callers know
+what data was available, what was missing, and how much to trust
+the result.
+
+Levels:
+  full — all required data sources available
+  fallback — some data missing, result is degraded but useful
+  analytical_only — no live data, pure heuristic
+  unavailable — cannot operate at all
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CapabilityReport:
+    """Operational state of an advanced tool invocation."""
+
+    level: str = "full"  # full, fallback, analytical_only, unavailable
+    confidence: float = 1.0
+    available_sources: list[str] = field(default_factory=list)
+    missing_sources: list[str] = field(default_factory=list)
+    fallback_used: str = ""
+    reason: str = ""
+
+    def to_dict(self) -> dict:
+        d = {"capability": self.level, "confidence": round(self.confidence, 2)}
+        if self.missing_sources:
+            d["missing"] = self.missing_sources
+        if self.fallback_used:
+            d["fallback"] = self.fallback_used
+        if self.reason:
+            d["reason"] = self.reason
+        return d
+
+
+def build_capability(
+    required: list[str],
+    available: dict[str, bool],
+) -> CapabilityReport:
+    """Build a capability report from required vs available data sources."""
+    missing = [r for r in required if not available.get(r, False)]
+    present = [r for r in required if available.get(r, False)]
+
+    if not missing:
+        return CapabilityReport(
+            level="full", confidence=1.0, available_sources=present,
+        )
+
+    if len(missing) == len(required):
+        return CapabilityReport(
+            level="analytical_only", confidence=0.2,
+            available_sources=[], missing_sources=missing,
+            reason="No required data sources available",
+        )
+
+    ratio = len(present) / len(required)
+    return CapabilityReport(
+        level="fallback", confidence=round(ratio * 0.8, 2),
+        available_sources=present, missing_sources=missing,
+        fallback_used="degraded inference from partial data",
+    )

package/mcp_server/runtime/capability_probe.py

@@ -0,0 +1,137 @@
+"""Runtime capability probe — detects what's available at startup.
+
+Reports capability tiers: Core Control, Analyzer-Enhanced,
+Offline Analysis, Creative Intelligence, Persistent Memory.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+
+def probe_capabilities(
+    ableton: Any = None,
+    ctx: Any = None,
+) -> dict:
+    """Probe runtime capabilities and return a structured report.
+
+    Can be called at startup or on demand via --doctor.
+    """
+    report: dict[str, dict] = {}
+
+    # 1. Ableton reachability
+    ableton_ok = False
+    if ableton is not None:
+        try:
+            info = ableton.send_command("ping")
+            ableton_ok = info is not None
+        except Exception:
+            pass
+    report["ableton"] = {
+        "status": "ok" if ableton_ok else "unavailable",
+        "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"] = {
+        "status": "ok",
+        "command_count": len(REMOTE_COMMANDS),
+        "detail": f"{len(REMOTE_COMMANDS)} registered commands",
+    }
+
+    # 3. M4L bridge
+    bridge_ok = False
+    if ctx 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",
+    }
+
+    # 4. Offline perception
+    numpy_ok = False
+    try:
+        import numpy  # noqa: F401
+        numpy_ok = True
+    except ImportError:
+        pass
+    report["offline_perception"] = {
+        "status": "ok" if numpy_ok else "degraded",
+        "detail": "numpy available" if numpy_ok else "numpy not installed — offline analysis unavailable",
+    }
+
+    # 5. Persistence
+    livepilot_dir = Path.home() / ".livepilot"
+    persistence_ok = livepilot_dir.exists() and os.access(livepilot_dir, os.W_OK)
+    taste_exists = (livepilot_dir / "taste.json").exists()
+    techniques_exists = (livepilot_dir / "memory" / "techniques.json").exists()
+    report["persistence"] = {
+        "status": "ok" if persistence_ok else "unavailable",
+        "detail": f"~/.livepilot/ {'writable' if persistence_ok else 'not found'}",
+        "taste_store": taste_exists,
+        "technique_store": techniques_exists,
+    }
+
+    # 6. Capability tier — highest active tier
+    if ableton_ok and bridge_ok:
+        tier = "analyzer_enhanced"
+    elif ableton_ok:
+        tier = "core_control"
+    else:
+        tier = "creative_intelligence"  # heuristic-only, no Ableton connection
+
+    report["tier"] = {
+        "active": tier,
+        "levels": {
+            "core_control": ableton_ok,
+            "analyzer_enhanced": ableton_ok and bridge_ok,
+            "offline_analysis": numpy_ok,
+            "creative_intelligence": True,  # always available
+            "persistent_memory": persistence_ok,
+        },
+    }
+
+    return report
+
+
+def format_doctor_report(report: dict) -> str:
+    """Format capability report for --doctor output."""
+    lines = ["LivePilot Capability Report", "=" * 40]
+
+    icons = {"ok": "  PASS", "unavailable": "  FAIL", "degraded": "  WARN"}
+
+    for area in ["ableton", "remote_script", "m4l_bridge", "offline_perception", "persistence"]:
+        info = report.get(area, {})
+        status = info.get("status", "unknown")
+        icon = icons.get(status, "  ????")
+        detail = info.get("detail", "")
+        lines.append(f"{icon}  {area}: {detail}")
+
+    tier = report.get("tier", {}).get("active", "unknown")
+    lines.append("")
+    lines.append(f"Active tier: {tier}")
+
+    return "\n".join(lines)

package/mcp_server/runtime/execution_router.py

@@ -0,0 +1,143 @@
+"""Unified execution router for compiled plan steps.
+
+Classifies each step by backend (remote_command, mcp_tool, bridge_command)
+and dispatches to the correct execution path. Replaces the pattern of
+sending everything through ableton.send_command() blindly.
+
+Step backends:
+  remote_command — valid Remote Script handler, goes through TCP
+  bridge_command — M4L bridge handler, goes through TCP (requires bridge)
+  mcp_tool — MCP-layer Python function, called directly
+  unknown — not a valid target anywhere
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from .remote_commands import BRIDGE_COMMANDS, REMOTE_COMMANDS
+
+
+# MCP-only tools that exist as Python functions but NOT as TCP handlers.
+# These must be called through direct import, not ableton.send_command().
+MCP_TOOLS: frozenset[str] = frozenset({
+    "apply_automation_shape",
+    "apply_gesture_template",
+    "analyze_mix",
+    "get_master_spectrum",
+    "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",
+})
+
+
+@dataclass
+class ExecutionResult:
+    """Result of executing a single plan step."""
+
+    ok: bool = False
+    backend: str = ""
+    tool: str = ""
+    result: Any = None
+    error: str = ""
+
+    def to_dict(self) -> dict:
+        d = {"ok": self.ok, "backend": self.backend, "tool": self.tool}
+        if self.ok:
+            d["result"] = self.result
+        else:
+            d["error"] = self.error
+        return d
+
+
+def classify_step(tool: str) -> str:
+    """Classify a step's execution backend."""
+    if tool in REMOTE_COMMANDS:
+        return "remote_command"
+    if tool in BRIDGE_COMMANDS:
+        return "bridge_command"
+    if tool in MCP_TOOLS:
+        return "mcp_tool"
+    return "unknown"
+
+
+def execute_step(
+    tool: str,
+    params: dict,
+    ableton: Any = None,
+    ctx: Any = None,
+    declared_backend: str | None = None,
+) -> ExecutionResult:
+    """Execute a single plan step through the correct backend."""
+    backend = declared_backend if declared_backend in ("remote_command", "bridge_command", "mcp_tool") else classify_step(tool)
+
+    if backend in ("remote_command", "bridge_command"):
+        if ableton is None:
+            return ExecutionResult(
+                ok=False, backend=backend, tool=tool,
+                error="Ableton connection unavailable",
+            )
+        try:
+            result = ableton.send_command(tool, params)
+            return ExecutionResult(ok=True, backend=backend, tool=tool, result=result)
+        except Exception as e:
+            return ExecutionResult(ok=False, backend=backend, tool=tool, error=str(e))
+
+    elif backend == "mcp_tool":
+        # MCP tools require direct Python dispatch.
+        # For now, return a clear error — full MCP dispatch is wired per-tool
+        # in the callers (apply_semantic_move, render_preview_variant).
+        return ExecutionResult(
+            ok=False, backend=backend, tool=tool,
+            error=f"MCP tool '{tool}' requires direct Python dispatch — "
+                  f"not executable through TCP. Use the MCP layer directly.",
+        )
+
+    else:
+        return ExecutionResult(
+            ok=False, backend="unknown", tool=tool,
+            error=f"Unknown tool '{tool}' — not a Remote Script command, "
+                  f"bridge command, or registered MCP tool",
+        )
+
+
+def execute_plan_steps(
+    steps: list[dict],
+    ableton: Any = None,
+    ctx: Any = None,
+    stop_on_failure: bool = True,
+) -> list[ExecutionResult]:
+    """Execute a list of plan steps, returning results for each.
+
+    Stops on first failure by default. Set stop_on_failure=False
+    to continue past errors (useful for best-effort execution).
+    """
+    results: list[ExecutionResult] = []
+
+    for step in steps:
+        tool = step.get("tool") or step.get("command", "")
+        params = step.get("params") or step.get("args", {})
+        # Honor declared backend from step annotations (PR5) if present
+        declared_backend = step.get("backend")
+
+        if not tool:
+            results.append(ExecutionResult(
+                ok=False, backend="unknown", tool="",
+                error="Step has no tool/command field",
+            ))
+            if stop_on_failure:
+                break
+            continue
+
+        result = execute_step(tool, params, ableton=ableton, ctx=ctx, declared_backend=declared_backend)
+        results.append(result)
+
+        if not result.ok and stop_on_failure:
+            break
+
+    return results

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

@@ -0,0 +1,87 @@
+"""Canonical set of all valid Remote Script commands.
+
+Every command here has a @register handler in remote_script/LivePilot/.
+This is the source of truth for what can be called via
+ableton.send_command(). If a command is not in this set, sending it
+through TCP will return NOT_FOUND from the Remote Script.
+
+Maintained manually — the Remote Script uses Ableton's Python and
+cannot be imported in CI. Update this when adding new handlers.
+"""
+
+REMOTE_COMMANDS: frozenset[str] = frozenset({
+    # transport (10)
+    "get_session_info", "set_tempo", "set_time_signature",
+    "start_playback", "stop_playback", "continue_playback",
+    "toggle_metronome", "set_session_loop", "undo", "redo",
+    # tracks (17)
+    "get_track_info", "create_midi_track", "create_audio_track",
+    "create_return_track", "delete_track", "duplicate_track",
+    "set_track_name", "set_track_color", "set_track_mute",
+    "set_track_solo", "set_track_arm", "stop_track_clips",
+    "set_group_fold", "set_track_input_monitoring",
+    "get_freeze_status", "freeze_track", "flatten_track",
+    # clips (11)
+    "get_clip_info", "create_clip", "delete_clip", "duplicate_clip",
+    "fire_clip", "stop_clip", "set_clip_name", "set_clip_color",
+    "set_clip_loop", "set_clip_launch", "set_clip_warp_mode",
+    # notes (8)
+    "add_notes", "get_notes", "remove_notes", "remove_notes_by_id",
+    "modify_notes", "duplicate_notes", "transpose_notes", "quantize_clip",
+    # mixing (11)
+    "set_track_volume", "set_track_pan", "set_track_send",
+    "get_return_tracks", "get_master_track", "set_master_volume",
+    "get_track_routing", "get_track_meters", "get_master_meters",
+    "get_mix_snapshot", "set_track_routing",
+    # scenes (12)
+    "get_scenes_info", "create_scene", "delete_scene", "duplicate_scene",
+    "fire_scene", "set_scene_name", "set_scene_color", "set_scene_tempo",
+    "get_scene_matrix", "fire_scene_clips", "stop_all_clips",
+    "get_playing_clips",
+    # 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 (6)
+    "get_browser_tree", "get_browser_items", "search_browser",
+    "load_browser_item", "get_device_presets",
+    "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",
+    "set_arrangement_automation", "transpose_arrangement_notes",
+    "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", "force_arrangement",
+    # diagnostics (1)
+    "get_session_diagnostics",
+    # ping (built-in)
+    "ping",
+})
+
+# M4L bridge commands — routed through TCP but handled by livepilot_bridge.js
+# These require the M4L Analyzer device on the master track.
+BRIDGE_COMMANDS: frozenset[str] = frozenset({
+    "get_params", "get_hidden_params", "get_auto_state", "walk_rack",
+    "get_chains_deep", "get_track_cpu", "get_selected", "get_key",
+    "get_clip_file_path", "replace_simpler_sample", "get_simpler_slices",
+    "crop_simpler", "reverse_simpler", "warp_simpler",
+    "get_warp_markers", "add_warp_marker", "move_warp_marker",
+    "remove_warp_marker", "capture_audio", "capture_stop",
+    "check_flucoma", "scrub_clip", "stop_scrub", "get_display_values",
+    "get_plugin_params", "map_plugin_param", "get_plugin_presets",
+    "load_sample_to_simpler",
+})
+
+# Combined: all valid send_command targets
+ALL_VALID_COMMANDS: frozenset[str] = REMOTE_COMMANDS | BRIDGE_COMMANDS

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."""