livepilot 1.10.8 → 1.12.2

package/remote_script/LivePilot/take_lanes.py

@@ -0,0 +1,175 @@
+"""
+LivePilot — Take Lanes handlers (Live 12.0 UI / 12.2 API).
+
+Take lanes are alternative clip rows stacked under an arrangement
+track — they let you audition or comp multiple passes of the same
+part without occupying extra tracks. Live 12.0 introduced them in
+the UI; the scripting API that lets us create/rename them and
+attach clips landed in Live 12.2.
+
+Read-only introspection (``get_take_lanes`` / ``get_take_lane_clips``)
+works on any Live 12.x since it's pure attribute traversal — we only
+feature-gate the mutation ops behind ``take_lanes_api`` (12.2.0).
+
+The ``track.take_lanes`` list grows through ``track.create_take_lane()``
+(when exposed) and each TakeLane exposes ``name``, ``is_frozen``,
+``clips``, and — in 12.2+ — ``create_audio_clip`` / ``create_midi_clip``.
+"""
+
+from .router import register
+from .utils import get_track
+
+
+def _get_take_lane(track, lane_index):
+    """Resolve a lane_index to a TakeLane object, raising IndexError on miss."""
+    lanes = list(getattr(track, "take_lanes", []))
+    idx = int(lane_index)
+    if not 0 <= idx < len(lanes):
+        raise IndexError(
+            "lane_index %d out of range (0..%d). Track has %d take lanes."
+            % (idx, len(lanes) - 1 if lanes else -1, len(lanes))
+        )
+    return lanes[idx]
+
+
+@register("get_take_lanes")
+def get_take_lanes(song, params):
+    """List all take lanes on a track.
+
+    Pure introspection — works on Live 12.0+ even when the creation
+    API isn't exposed. Returns an empty list if the track doesn't
+    expose ``take_lanes`` at all.
+    """
+    track = get_track(song, int(params["track_index"]))
+    lanes = getattr(track, "take_lanes", None)
+    if lanes is None:
+        return {"lanes": []}
+    out = []
+    for i, lane in enumerate(lanes):
+        out.append({
+            "index": i,
+            "name": str(getattr(lane, "name", "")),
+            "is_frozen": bool(getattr(lane, "is_frozen", False)),
+            "clip_count": len(list(getattr(lane, "clips", []))),
+        })
+    return {"lanes": out}
+
+
+@register("create_take_lane")
+def create_take_lane(song, params):
+    """Create a new take lane on a track (Live 12.2+).
+
+    Returns the new lane's index and name. Raises if the Live version
+    predates 12.2 or if the specific build doesn't expose
+    ``Track.create_take_lane`` — some pre-release 12.2 builds shipped
+    the TakeLane read surface without the create method.
+    """
+    from .version_detect import has_feature
+    if not has_feature("take_lanes_api"):
+        raise RuntimeError("Take lane creation requires Live 12.2+.")
+    track = get_track(song, int(params["track_index"]))
+    if not hasattr(track, "create_take_lane"):
+        raise RuntimeError(
+            "Track.create_take_lane is not available in this Live version."
+        )
+    track.create_take_lane()
+    lanes = list(track.take_lanes)
+    new_index = len(lanes) - 1
+    lane = lanes[new_index]
+    return {
+        "lane_index": new_index,
+        "name": str(getattr(lane, "name", "")),
+    }
+
+
+@register("set_take_lane_name")
+def set_take_lane_name(song, params):
+    """Rename an existing take lane (Live 12.2+)."""
+    from .version_detect import has_feature
+    if not has_feature("take_lanes_api"):
+        raise RuntimeError("Take lane rename requires Live 12.2+.")
+    track = get_track(song, int(params["track_index"]))
+    lane = _get_take_lane(track, params["lane_index"])
+    lane.name = str(params["name"])
+    return {"name": str(lane.name)}
+
+
+@register("create_audio_clip_on_take_lane")
+def create_audio_clip_on_take_lane(song, params):
+    """Create an arrangement audio clip on a specific take lane (Live 12.2+).
+
+    start_time / length are in beats. length must be > 0. The track
+    must be an audio track — Live will raise if called on a MIDI track.
+    """
+    from .version_detect import has_feature
+    if not has_feature("take_lanes_api"):
+        raise RuntimeError("Take lane clip creation requires Live 12.2+.")
+    track = get_track(song, int(params["track_index"]))
+    lane = _get_take_lane(track, params["lane_index"])
+    if not hasattr(lane, "create_audio_clip"):
+        raise RuntimeError(
+            "TakeLane.create_audio_clip is not available in this Live version."
+        )
+    start = float(params["start_time"])
+    length = float(params["length"])
+    if length <= 0:
+        raise ValueError("length must be > 0")
+    lane.create_audio_clip(start, length)
+    return {
+        "ok": True,
+        "track_index": int(params["track_index"]),
+        "lane_index": int(params["lane_index"]),
+        "start_time": start,
+        "length": length,
+    }
+
+
+@register("create_midi_clip_on_take_lane")
+def create_midi_clip_on_take_lane(song, params):
+    """Create an arrangement MIDI clip on a specific take lane (Live 12.2+).
+
+    start_time / length are in beats. length must be > 0. The track
+    must be a MIDI track — Live will raise if called on an audio track.
+    """
+    from .version_detect import has_feature
+    if not has_feature("take_lanes_api"):
+        raise RuntimeError("Take lane clip creation requires Live 12.2+.")
+    track = get_track(song, int(params["track_index"]))
+    lane = _get_take_lane(track, params["lane_index"])
+    if not hasattr(lane, "create_midi_clip"):
+        raise RuntimeError(
+            "TakeLane.create_midi_clip is not available in this Live version."
+        )
+    start = float(params["start_time"])
+    length = float(params["length"])
+    if length <= 0:
+        raise ValueError("length must be > 0")
+    lane.create_midi_clip(start, length)
+    return {
+        "ok": True,
+        "track_index": int(params["track_index"]),
+        "lane_index": int(params["lane_index"]),
+        "start_time": start,
+        "length": length,
+    }
+
+
+@register("get_take_lane_clips")
+def get_take_lane_clips(song, params):
+    """List the arrangement clips on a specific take lane.
+
+    Pure introspection — no version gate. Returns ``{clips: [...]}``
+    where each clip entry has name, start_time, length, and
+    is_midi_clip.
+    """
+    track = get_track(song, int(params["track_index"]))
+    lane = _get_take_lane(track, params["lane_index"])
+    out = []
+    for clip in getattr(lane, "clips", []):
+        out.append({
+            "name": str(getattr(clip, "name", "")),
+            "start_time": float(getattr(clip, "start_time", 0.0)),
+            "length": float(getattr(clip, "length", 0.0)),
+            "is_midi_clip": bool(getattr(clip, "is_midi_clip", False)),
+        })
+    return {"clips": out}

package/remote_script/LivePilot/tracks.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Track domain handlers (17 commands).
+LivePilot - Track domain handlers (20 commands).
 """
 
 from .router import register
@@ -404,3 +404,61 @@ def flatten_track(song, params):
         "track_index": track_index,
         "flattened": True,
     }
+
+
+# ── Track long-tail primitives ──────────────────────────────────────────
+
+
+@register("jump_in_session_clip")
+def jump_in_session_clip(song, params):
+    """Jump playhead within a running session clip, in beats from start."""
+    track = get_track(song, int(params["track_index"]))
+    beats = float(params["beats"])
+    if not hasattr(track, "jump_in_running_session_clip"):
+        raise RuntimeError("jump_in_running_session_clip not exposed")
+    track.jump_in_running_session_clip(beats)
+    return {"track_index": int(params["track_index"]), "beats": beats}
+
+
+@register("get_track_performance_impact")
+def get_track_performance_impact(song, params):
+    """Read a track's CPU performance impact metric."""
+    track = get_track(song, int(params["track_index"]))
+    val = float(getattr(track, "performance_impact", 0.0))
+    return {"performance_impact": val}
+
+
+@register("get_appointed_device")
+def get_appointed_device(song, params):
+    """Return the Blue Hand (appointed/focused) device location.
+
+    Maps the Device object back to (track_index, device_index) by
+    scanning all tracks. Normalized track indices: 0..N-1 for regular
+    tracks, -1=A, -2=B, etc. for returns, -1000 for the master track.
+    """
+    dev = getattr(song, "appointed_device", None)
+    if dev is None:
+        return {"track_index": -1, "device_index": -1,
+                "track_name": "", "device_name": ""}
+    tracks = list(song.tracks)
+    returns = list(song.return_tracks)
+    master = song.master_track
+    for ti, track in enumerate(tracks):
+        for di, d in enumerate(track.devices):
+            if d == dev:
+                return {"track_index": ti, "device_index": di,
+                        "track_name": str(track.name),
+                        "device_name": str(d.name)}
+    for ti, track in enumerate(returns):
+        for di, d in enumerate(track.devices):
+            if d == dev:
+                return {"track_index": -1 - ti, "device_index": di,
+                        "track_name": str(track.name),
+                        "device_name": str(d.name)}
+    for di, d in enumerate(master.devices):
+        if d == dev:
+            return {"track_index": -1000, "device_index": di,
+                    "track_name": str(master.name),
+                    "device_name": str(d.name)}
+    return {"track_index": -1, "device_index": -1,
+            "track_name": "", "device_name": str(getattr(dev, "name", ""))}

package/remote_script/LivePilot/transport.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Transport domain handlers (10 commands).
+LivePilot - Transport domain handlers (19 commands).
 """
 
 from .router import register
@@ -152,3 +152,92 @@ def redo(song, params):
     """Redo the last undone action."""
     song.redo()
     return {"redone": True}
+
+
+# ── Song / Transport long-tail primitives ─────────────────────────────
+
+
+@register("tap_tempo")
+def tap_tempo(song, params):
+    """Tap the tempo (one tap); Live averages consecutive taps."""
+    song.tap_tempo()
+    return {"tempo": float(song.tempo)}
+
+
+@register("nudge_tempo")
+def nudge_tempo(song, params):
+    """Nudge tempo up or down by Live's internal nudge delta."""
+    direction = str(params["direction"]).lower()
+    if direction == "up":
+        song.nudge_up()
+    elif direction == "down":
+        song.nudge_down()
+    else:
+        raise ValueError("direction must be 'up' or 'down'")
+    return {"tempo": float(song.tempo)}
+
+
+@register("set_exclusive_arm")
+def set_exclusive_arm(song, params):
+    """Enable/disable exclusive arm (only one track armed at a time)."""
+    song.exclusive_arm = bool(params["enabled"])
+    return {"exclusive_arm": bool(song.exclusive_arm)}
+
+
+@register("set_exclusive_solo")
+def set_exclusive_solo(song, params):
+    """Enable/disable exclusive solo mode."""
+    song.exclusive_solo = bool(params["enabled"])
+    return {"exclusive_solo": bool(song.exclusive_solo)}
+
+
+@register("capture_and_insert_scene")
+def capture_and_insert_scene(song, params):
+    """Capture currently-playing clips and insert them as a new scene."""
+    before_count = len(list(song.scenes))
+    song.capture_and_insert_scene()
+    scenes = list(song.scenes)
+    new_idx = len(scenes) - 1
+    # capture_and_insert_scene inserts at a specific position — find the new one.
+    # Safest: if count grew by 1, the new scene is at the end; otherwise return -1.
+    if len(scenes) > before_count:
+        return {"scene_index": new_idx, "scene_name": str(scenes[new_idx].name)}
+    return {"scene_index": -1, "scene_name": ""}
+
+
+@register("set_count_in_duration")
+def set_count_in_duration(song, params):
+    """Set pre-record count-in (0-4 bars)."""
+    bars = int(params["bars"])
+    if not 0 <= bars <= 4:
+        raise ValueError("bars must be 0-4")
+    song.count_in_duration = bars
+    return {"count_in_duration": int(song.count_in_duration)}
+
+
+@register("get_link_state")
+def get_link_state(song, params):
+    """Read Ableton Link + count-in state."""
+    return {
+        "enabled": bool(getattr(song, "is_ableton_link_enabled", False)),
+        "start_stop_sync": bool(getattr(song, "is_ableton_link_start_stop_sync_enabled", False)),
+        "tempo_follower": bool(getattr(song, "tempo_follower_enabled", False)),
+        "is_counting_in": bool(getattr(song, "is_counting_in", False)),
+    }
+
+
+@register("set_link_enabled")
+def set_link_enabled(song, params):
+    """Enable or disable Ableton Link."""
+    song.is_ableton_link_enabled = bool(params["enabled"])
+    return {"enabled": bool(song.is_ableton_link_enabled)}
+
+
+@register("force_link_beat_time")
+def force_link_beat_time(song, params):
+    """Force Link to a specific beat time (if supported)."""
+    if not hasattr(song, "force_link_beat_time"):
+        raise RuntimeError("force_link_beat_time is not exposed in this Live version.")
+    beat_time = float(params["beat_time"])
+    song.force_link_beat_time(beat_time)
+    return {"ok": True, "beat_time": beat_time}

package/remote_script/LivePilot/version_detect.py

@@ -10,17 +10,26 @@ import Live
 # ── Feature version requirements ────────────────────────────────────────
 
 FEATURES = {
+    "song_scale_api": (12, 0, 0),
+    "clip_follow_action_v2": (12, 0, 0),
+    "miditool_api": (12, 0, 0),
     "create_midi_clip_arrangement": (12, 1, 10),
     "looper_export": (12, 1, 0),
     "tuning_system": (12, 1, 0),
     "display_value": (12, 2, 0),
     "clip_start_time_observable": (12, 2, 0),
     "take_lanes_api": (12, 2, 0),
+    "scene_follow_actions": (12, 2, 0),
     "insert_device": (12, 3, 0),
     "insert_chain": (12, 3, 0),
     "drum_chain_in_note": (12, 3, 0),
     "stem_separation": (12, 3, 0),
+    "device_ab_compare": (12, 3, 0),
     "replace_sample_native": (12, 4, 0),
+    "groove_pool_api": (11, 0, 0),
+    "rack_variations_api": (11, 0, 0),
+    "simpler_slice_crud": (11, 0, 0),
+    "wavetable_mod_matrix": (11, 0, 0),
 }
 
 

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "323-tool agentic MCP production system for Ableton Live 12 — device atlas, sample engine, composer",
+  "description": "398-tool agentic MCP production system for Ableton Live 12 — device atlas, sample engine, composer",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.10.8",
+  "version": "1.12.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.10.8",
+      "version": "1.12.2",
       "transport": {
         "type": "stdio"
       }