livepilot 1.9.24 → 1.10.1

package/mcp_server/runtime/mcp_dispatch.py

@@ -0,0 +1,46 @@
+"""Registry of in-process MCP tools callable from the async execution router.
+
+These tools live as Python async functions in the MCP server — not TCP Remote
+Script handlers and not M4L bridge commands. Plans that want to invoke them
+go through this registry so the async router can dispatch them in-process.
+
+Each entry is a thin wrapper around the real MCP tool import, keeping the
+module cheap to import (no heavy server wiring until a caller actually
+dispatches an MCP step).
+
+To add a new in-process tool to plans:
+  1. Add the tool name to MCP_TOOLS in execution_router.py so classify_step
+     returns "mcp_tool" for it.
+  2. Add an _adapter function here that imports the real implementation and
+     adapts its kwargs from a plan-style params dict.
+  3. Register the adapter in build_mcp_dispatch_registry.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+async def _load_sample_to_simpler(params: dict, ctx: Any = None) -> dict:
+    """Adapter for mcp_server.tools.analyzer.load_sample_to_simpler.
+
+    Accepts the plan-step params dict and unpacks into the real tool's kwargs.
+    """
+    from ..tools.analyzer import load_sample_to_simpler
+    return await load_sample_to_simpler(
+        ctx,
+        track_index=int(params["track_index"]),
+        file_path=str(params["file_path"]),
+        device_index=int(params.get("device_index", 0)),
+    )
+
+
+def build_mcp_dispatch_registry() -> dict[str, Callable]:
+    """Return the canonical registry of MCP-only tools for plan execution.
+
+    Callers (typically the server lifespan init) should call this once and
+    pass the registry to execute_plan_steps_async via the mcp_registry kwarg.
+    """
+    return {
+        "load_sample_to_simpler": _load_sample_to_simpler,
+    }

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)
@@ -75,7 +80,10 @@ BRIDGE_COMMANDS: frozenset[str] = frozenset({
     "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",
+    # NOTE: load_sample_to_simpler used to live here, but it's actually an
+    # async Python MCP tool in mcp_server/tools/analyzer.py, not a bridge
+    # command. It has no case in livepilot_bridge.js and no @register handler
+    # in remote_script. See mcp_server/runtime/execution_router.MCP_TOOLS.
 })
 
 # Combined: all valid send_command targets

package/mcp_server/runtime/tools.py

@@ -94,52 +94,75 @@ 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,
     )
 
-    # Optional subcomponents — degrade gracefully
-    ledger_summary = {}
-    taste_graph = {}
-    anti_prefs = []
-    session_mem = []
+    # Optional subcomponents — degrade gracefully, but reach into the SAME
+    # session-scoped stores the public memory tools read/write via
+    # ctx.lifespan_context.setdefault(...). Creating fresh stores here meant
+    # users who recorded anti-preferences, session memory, or taste signals
+    # through the MCP tools always saw an empty kernel.
+    ledger_summary: dict = {}
+    taste_graph: dict = {}
+    anti_prefs: list = []
+    session_mem: list = []
+    kernel_warnings: list[str] = []
 
     try:
-        from .action_ledger import ActionLedger
-        ledger = ActionLedger.instance()
-        if ledger:
-            ledger_summary = ledger.summary()
-    except Exception:
-        pass
-
+        from .action_ledger import SessionLedger
+        ledger = ctx.lifespan_context.get("action_ledger")
+        if ledger is None:
+            ledger = SessionLedger()
+            ctx.lifespan_context["action_ledger"] = ledger
+        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 as e:
+        kernel_warnings.append(f"ledger_unavailable: {e}")
+
+    # Taste graph + anti-prefs — share stores via lifespan_context, use the
+    # canonical build_taste_graph() so consumers see dimension_weights shape.
     try:
+        from ..memory.taste_graph import build_taste_graph
         from ..memory.taste_memory import TasteMemoryStore
-        taste_store = TasteMemoryStore()
-        taste_graph = {d.name: d.to_dict() for d in taste_store._dims.values()
-                       if d.evidence_count > 0}
-    except Exception:
-        pass
-
-    try:
         from ..memory.anti_memory import AntiMemoryStore
-        anti_store = AntiMemoryStore()
-        anti_prefs = anti_store.list_all()
-    except Exception:
-        pass
+        from ..persistence.taste_store import PersistentTasteStore
+        taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
+        anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
+        persistent = ctx.lifespan_context.setdefault("persistent_taste", PersistentTasteStore())
+        graph = build_taste_graph(
+            taste_store=taste_store,
+            anti_store=anti_store,
+            persistent_store=persistent,
+        )
+        taste_graph = graph.to_dict()
+        anti_prefs = [p.to_dict() for p in anti_store.get_anti_preferences()]
+    except Exception as e:
+        kernel_warnings.append(f"taste_graph_unavailable: {e}")
 
     try:
         from ..memory.session_memory import SessionMemoryStore
-        mem_store = SessionMemoryStore()
-        session_mem = mem_store.recent(limit=10)
-    except Exception:
-        pass
+        mem_store = ctx.lifespan_context.setdefault("session_memory", SessionMemoryStore())
+        session_mem = [entry.to_dict() for entry in mem_store.get_recent(limit=10)]
+    except Exception as e:
+        kernel_warnings.append(f"session_memory_unavailable: {e}")
 
     kernel = build_session_kernel(
         session_info=session_info,
@@ -153,4 +176,18 @@ def get_session_kernel(
         anti_preferences=anti_prefs,
     )
 
-    return kernel.to_dict()
+    # Populate routing hints from conductor when request context is available
+    if request_text.strip():
+        try:
+            from ..tools._conductor import classify_request
+            plan = classify_request(request_text)
+            kernel.recommended_engines = [r.engine for r in plan.routes[:3]]
+            kernel.recommended_workflow = plan.workflow_mode
+        except Exception as e:
+            kernel_warnings.append(f"conductor_routing_unavailable: {e}")
+
+    result_dict = kernel.to_dict()
+    if kernel_warnings:
+        # Additive — callers can ignore; debug-mode introspection benefits.
+        result_dict["warnings"] = kernel_warnings
+    return result_dict

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