livepilot 1.8.3 → 1.9.0

package/mcp_server/tools/midi_io.py

@@ -14,6 +14,7 @@ from typing import Any, Optional
 
 from fastmcp import Context
 
+from ..connection import AbletonConnectionError
 from ..server import mcp
 from . import _theory_engine as theory
 
@@ -59,6 +60,27 @@ def _validate_midi_path(file_path: str) -> Path:
     return p
 
 
+def _midi_notes_to_beats(pm) -> list[dict]:
+    """Convert pretty_midi notes to beat-position dicts using the file's own tempo map.
+
+    Uses time_to_tick/resolution to preserve the MIDI file's beat grid,
+    regardless of the current Ableton session tempo.
+    """
+    notes_raw = []
+    for inst in pm.instruments:
+        for n in inst.notes:
+            start_beat = round(pm.time_to_tick(n.start) / pm.resolution, 3)
+            end_beat = round(pm.time_to_tick(n.end) / pm.resolution, 3)
+            dur_beat = round(end_beat - start_beat, 3)
+            notes_raw.append({
+                "pitch": n.pitch,
+                "start_time": start_beat,
+                "duration": max(dur_beat, 0.001),
+                "velocity": n.velocity,
+            })
+    return notes_raw
+
+
 # -- Tool 1: export_clip_midi ------------------------------------------------
 
 @mcp.tool()
@@ -127,8 +149,10 @@ def import_midi_to_clip(
 ) -> dict:
     """Load a .mid file into a session clip.
 
-    Reads MIDI, converts timing to beats using session tempo, and writes
-    notes into the target clip slot. Creates the clip if needed.
+    Reads MIDI, converts timing to beats using the file's own tempo map,
+    and writes notes into the target clip slot. When create_clip=True
+    (default), creates a new clip if the slot is empty; if a clip already
+    exists, clears its notes before importing.
     """
     pretty_midi = _require_pretty_midi()
     ableton = _get_ableton(ctx)
@@ -136,20 +160,8 @@ def import_midi_to_clip(
     path = _validate_midi_path(file_path)
     pm = pretty_midi.PrettyMIDI(str(path))
 
-    session = ableton.send_command("get_session_info", {})
-    tempo = float(session.get("tempo", 120.0))
-
-    notes_raw = []
-    for inst in pm.instruments:
-        for n in inst.notes:
-            start_beat = round(n.start * (tempo / 60.0), 3)
-            dur_beat = round((n.end - n.start) * (tempo / 60.0), 3)
-            notes_raw.append({
-                "pitch": n.pitch,
-                "start_time": start_beat,
-                "duration": max(dur_beat, 0.001),
-                "velocity": n.velocity,
-            })
+    # Convert using the MIDI file's own tempo map (not session tempo)
+    notes_raw = _midi_notes_to_beats(pm)
 
     seen = set()
     notes = []
@@ -165,11 +177,31 @@ def import_midi_to_clip(
                          default=4.0)
 
     if create_clip:
-        ableton.send_command("create_clip", {
-            "track_index": track_index,
-            "clip_index": clip_index,
-            "length": round(duration_beats, 2),
-        })
+        # Check if clip already exists — only create if the slot is empty
+        slot_has_clip = False
+        try:
+            ableton.send_command("get_clip_info", {
+                "track_index": track_index,
+                "clip_index": clip_index,
+            })
+            slot_has_clip = True
+        except AbletonConnectionError:
+            # Slot is empty — no clip to clear
+            pass
+
+        if slot_has_clip:
+            # Clip exists — clear its notes before importing
+            ableton.send_command("remove_notes", {
+                "track_index": track_index,
+                "clip_index": clip_index,
+            })
+        else:
+            # Empty slot — create a new clip
+            ableton.send_command("create_clip", {
+                "track_index": track_index,
+                "clip_index": clip_index,
+                "length": round(duration_beats, 2),
+            })
 
     if notes:
         ableton.send_command("add_notes", {
@@ -178,10 +210,13 @@ def import_midi_to_clip(
             "notes": notes,
         })
 
+    tempo_changes = pm.get_tempo_changes()
+    midi_tempo = float(tempo_changes[1][0]) if len(tempo_changes[1]) > 0 else 120.0
+
     return {
         "note_count": len(notes),
         "duration_beats": round(duration_beats, 4),
-        "tempo_source": tempo,
+        "midi_tempo": midi_tempo,
     }
 
 

package/mcp_server/tools/notes.py

@@ -135,6 +135,10 @@ def remove_notes(
     """Remove all MIDI notes in a pitch/time region. Use undo to revert. Defaults remove ALL notes in the clip."""
     _validate_track_index(track_index)
     _validate_clip_index(clip_index)
+    if not 0 <= from_pitch <= 127:
+        raise ValueError("from_pitch must be 0-127")
+    if pitch_span < 1 or pitch_span > 128:
+        raise ValueError("pitch_span must be 1-128")
     params = {
         "track_index": track_index,
         "clip_index": clip_index,

package/mcp_server/tools/scenes.py

@@ -1,8 +1,11 @@
-"""Scene MCP tools — list, create, delete, duplicate, fire, rename, color, tempo.
+"""Scene MCP tools — list, create, delete, duplicate, fire, rename, color, tempo, matrix.
 
-8 tools matching the Remote Script scenes domain.
+12 tools matching the Remote Script scenes domain.
 """
 
+import json
+from typing import Any, Optional
+
 from fastmcp import Context
 
 from ..server import mcp
@@ -87,3 +90,63 @@ def set_scene_tempo(ctx: Context, scene_index: int, tempo: float) -> dict:
         "scene_index": scene_index,
         "tempo": tempo,
     })
+
+
+# ── Scene Matrix Operations ─────────────────────────────────────────────
+
+
+def _ensure_list(value: Any) -> list:
+    if isinstance(value, str):
+        return json.loads(value)
+    return value
+
+
+@mcp.tool()
+def get_scene_matrix(ctx: Context) -> dict:
+    """Get the full session clip grid: every track x every scene.
+
+    Returns clip states (empty/stopped/playing/triggered/recording),
+    clip names, and colors. Use this for a bird's-eye view of the
+    entire session before making clip launch decisions.
+    """
+    return _get_ableton(ctx).send_command("get_scene_matrix")
+
+
+@mcp.tool()
+def fire_scene_clips(
+    ctx: Context,
+    scene_index: int,
+    track_indices: Optional[Any] = None,
+) -> dict:
+    """Fire a scene, optionally filtering to specific tracks.
+
+    If track_indices is omitted, fires the entire scene (all tracks).
+    If provided (JSON array of ints), fires only those tracks' clip slots
+    from the scene — useful for launching drums + bass without triggering
+    the lead, or building up layers gradually.
+    """
+    _validate_scene_index(scene_index)
+    params: dict = {"scene_index": scene_index}
+    if track_indices is not None:
+        track_indices = _ensure_list(track_indices)
+        for ti in track_indices:
+            if int(ti) < 0:
+                raise ValueError("track_indices must all be >= 0")
+        params["track_indices"] = track_indices
+    return _get_ableton(ctx).send_command("fire_scene_clips", params)
+
+
+@mcp.tool()
+def stop_all_clips(ctx: Context) -> dict:
+    """Stop all playing clips in the session. Panic button."""
+    return _get_ableton(ctx).send_command("stop_all_clips")
+
+
+@mcp.tool()
+def get_playing_clips(ctx: Context) -> dict:
+    """Get all currently playing or triggered clips.
+
+    Returns track index/name, clip index/name, and whether each clip
+    is actively playing or just triggered (waiting for quantization).
+    """
+    return _get_ableton(ctx).send_command("get_playing_clips")

package/mcp_server/tools/tracks.py

@@ -1,6 +1,6 @@
-"""Track MCP tools — create, delete, rename, mute, solo, arm, group fold, monitor.
+"""Track MCP tools — create, delete, rename, mute, solo, arm, group fold, monitor, freeze, flatten.
 
-14 tools matching the Remote Script tracks domain.
+17 tools matching the Remote Script tracks domain.
 """
 
 from __future__ import annotations
@@ -173,3 +173,46 @@ def set_track_input_monitoring(ctx: Context, track_index: int, state: int) -> di
         "track_index": track_index,
         "state": state,
     })
+
+
+# ── Freeze / Flatten ────────────────────────────────────────────────────
+
+
+@mcp.tool()
+def freeze_track(ctx: Context, track_index: int) -> dict:
+    """Freeze a track — render all devices to audio for CPU savings.
+
+    Freeze is async in Ableton: this initiates the render and returns
+    immediately. Poll get_freeze_status to check when it's done.
+    Freezing a track that's already frozen is a no-op.
+    """
+    _validate_track_index(track_index)
+    return _get_ableton(ctx).send_command("freeze_track", {
+        "track_index": track_index,
+    })
+
+
+@mcp.tool()
+def flatten_track(ctx: Context, track_index: int) -> dict:
+    """Flatten a frozen track — commit rendered audio permanently.
+
+    Destructive: replaces all devices with the rendered audio file.
+    The track must already be frozen. Use undo to revert.
+    """
+    _validate_track_index(track_index)
+    return _get_ableton(ctx).send_command("flatten_track", {
+        "track_index": track_index,
+    })
+
+
+@mcp.tool()
+def get_freeze_status(ctx: Context, track_index: int) -> dict:
+    """Check if a track is frozen.
+
+    Use after freeze_track to poll for completion, or before
+    flatten_track to verify the track is ready to flatten.
+    """
+    _validate_track_index(track_index)
+    return _get_ableton(ctx).send_command("get_freeze_status", {
+        "track_index": track_index,
+    })

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.8.3",
+  "version": "1.9.0",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 168 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "description": "Agentic production system for Ableton Live 12 — 178 tools, 17 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": "Pilot Studio",
   "license": "MIT",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.8.3"
+__version__ = "1.9.0"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer
@@ -34,7 +34,7 @@ class LivePilot(ControlSurface):
         ControlSurface.__init__(self, c_instance)
         self._server = LivePilotServer(self)
         self._server.start()
-        self.log_message("LivePilot v1.8.1 initialized")
+        self.log_message("LivePilot v%s initialized" % __version__)
         self.show_message("LivePilot: Listening on port 9878")
 
     def disconnect(self):

package/remote_script/LivePilot/arrangement.py

@@ -61,6 +61,8 @@ def create_arrangement_clip(song, params):
 
     # Use loop_length as the repeat unit (defaults to source clip length)
     loop_length = float(params.get("loop_length", source_length))
+    if loop_length <= 0:
+        raise ValueError("loop_length must be > 0")
 
     name = str(params.get("name", ""))
     color_index = params.get("color_index")
@@ -86,10 +88,50 @@ def create_arrangement_clip(song, params):
                         c.name = name
                     if color_index is not None:
                         c.color_index = int(color_index)
+
+                    # When loop_length < source_length, set the internal
+                    # loop region so only loop_length beats of content play.
+                    # Arrangement clip timeline length is read-only in the
+                    # LOM, but overlapping clips are handled by Ableton
+                    # (later clips take priority), so playback is correct.
+                    remaining = end_pos - pos
+                    target_len = min(loop_length, remaining)
+                    if target_len < source_length:
+                        try:
+                            c.looping = True
+                            c.loop_start = 0.0
+                            c.loop_end = target_len
+                        except (AttributeError, RuntimeError):
+                            pass
                     break
 
             clip_count += 1
             pos += loop_length
+
+        # Trim the last clip's overshoot: if the last duplicate extends
+        # past end_pos, remove notes beyond the requested region and
+        # set loop_end so only the needed portion plays.
+        if clip_count > 0:
+            arr_clips = list(track.arrangement_clips)
+            for c in arr_clips:
+                clip_end = c.start_time + c.length
+                if c.start_time >= start_time and clip_end > end_pos + 0.01:
+                    # This clip overshoots — trim its content
+                    overshoot_start = end_pos - c.start_time
+                    if overshoot_start > 0:
+                        try:
+                            c.looping = True
+                            c.loop_start = 0.0
+                            c.loop_end = overshoot_start
+                        except (AttributeError, RuntimeError):
+                            pass
+                        # Remove notes beyond the trim point
+                        try:
+                            c.remove_notes_extended(
+                                0, 128, overshoot_start, c.length
+                            )
+                        except Exception:
+                            pass
     finally:
         song.end_undo_step()
 

package/remote_script/LivePilot/clip_automation.py

@@ -12,8 +12,8 @@ from .utils import get_track, get_clip
 @register("get_clip_automation")
 def get_clip_automation(song, params):
     """List automation envelopes on a session clip."""
-    track_index = params["track_index"]
-    clip_index = params["clip_index"]
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
 
     track = get_track(song, track_index)
     clip = get_clip(song, track_index, clip_index)
@@ -80,8 +80,8 @@ def set_clip_automation(song, params):
     parameter_type: "device", "volume", "panning", "send"
     points: [{time, value, duration?}] — time relative to clip start
     """
-    track_index = params["track_index"]
-    clip_index = params["clip_index"]
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
     parameter_type = params["parameter_type"]
     points = params["points"]
     device_index = params.get("device_index")
@@ -98,29 +98,23 @@ def set_clip_automation(song, params):
         parameter = track.mixer_device.panning
     elif parameter_type == "send":
         if send_index is None:
-            return {"error": {"code": "INVALID_PARAM",
-                    "message": "send_index required for send automation"}}
+            raise ValueError("send_index required for send automation")
         sends = list(track.mixer_device.sends)
         if send_index < 0 or send_index >= len(sends):
-            return {"error": {"code": "INDEX_ERROR",
-                    "message": "send_index %d out of range" % send_index}}
+            raise IndexError("send_index %d out of range" % send_index)
         parameter = sends[send_index]
     elif parameter_type == "device":
         if device_index is None or parameter_index is None:
-            return {"error": {"code": "INVALID_PARAM",
-                    "message": "device_index and parameter_index required"}}
+            raise ValueError("device_index and parameter_index required")
         devices = list(track.devices)
         if device_index < 0 or device_index >= len(devices):
-            return {"error": {"code": "INDEX_ERROR",
-                    "message": "device_index %d out of range" % device_index}}
+            raise IndexError("device_index %d out of range" % device_index)
         dev_params = list(devices[device_index].parameters)
         if parameter_index < 0 or parameter_index >= len(dev_params):
-            return {"error": {"code": "INDEX_ERROR",
-                    "message": "parameter_index %d out of range" % parameter_index}}
+            raise IndexError("parameter_index %d out of range" % parameter_index)
         parameter = dev_params[parameter_index]
     else:
-        return {"error": {"code": "INVALID_PARAM",
-                "message": "parameter_type must be device/volume/panning/send"}}
+        raise ValueError("parameter_type must be device/volume/panning/send")
 
     # Get or create envelope
     song.begin_undo_step()
@@ -158,8 +152,8 @@ def clear_clip_automation(song, params):
     If parameter_type is provided, clears only that parameter's envelope.
     If omitted, clears ALL envelopes on the clip.
     """
-    track_index = params["track_index"]
-    clip_index = params["clip_index"]
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
     parameter_type = params.get("parameter_type")
 
     track = get_track(song, track_index)
@@ -184,31 +178,25 @@ def clear_clip_automation(song, params):
         elif parameter_type == "send":
             send_index = params.get("send_index")
             if send_index is None:
-                return {"error": {"code": "INVALID_PARAM",
-                        "message": "send_index required for send automation"}}
+                raise ValueError("send_index required for send automation")
             sends = list(track.mixer_device.sends)
             if send_index < 0 or send_index >= len(sends):
-                return {"error": {"code": "INDEX_ERROR",
-                        "message": "send_index %d out of range" % send_index}}
+                raise IndexError("send_index %d out of range" % send_index)
             parameter = sends[send_index]
         elif parameter_type == "device":
             device_index = params.get("device_index")
             parameter_index = params.get("parameter_index")
             if device_index is None or parameter_index is None:
-                return {"error": {"code": "INVALID_PARAM",
-                        "message": "device_index and parameter_index required"}}
+                raise ValueError("device_index and parameter_index required")
             devices = list(track.devices)
             if device_index < 0 or device_index >= len(devices):
-                return {"error": {"code": "INDEX_ERROR",
-                        "message": "device_index %d out of range" % device_index}}
+                raise IndexError("device_index %d out of range" % device_index)
             dev_params = list(devices[device_index].parameters)
             if parameter_index < 0 or parameter_index >= len(dev_params):
-                return {"error": {"code": "INDEX_ERROR",
-                        "message": "parameter_index %d out of range" % parameter_index}}
+                raise IndexError("parameter_index %d out of range" % parameter_index)
             parameter = dev_params[parameter_index]
         else:
-            return {"error": {"code": "INVALID_PARAM",
-                    "message": "Unknown parameter_type"}}
+            raise ValueError("Unknown parameter_type")
 
         clip.clear_envelope(parameter)
     finally:

package/remote_script/LivePilot/scenes.py

@@ -1,5 +1,5 @@
 """
-LivePilot - Scene domain handlers (8 commands).
+LivePilot - Scene domain handlers (12 commands).
 """
 
 from .router import register
@@ -97,3 +97,112 @@ def set_scene_tempo(song, params):
         "index": scene_index,
         "tempo": scene.tempo,
     }
+
+
+# ── Scene Matrix Operations ─────────────────────────────────────────────
+
+
+@register("get_scene_matrix")
+def get_scene_matrix(song, params):
+    """Return the full clip grid: tracks x scenes with clip states."""
+    tracks = list(song.tracks)
+    scenes = list(song.scenes)
+
+    track_headers = []
+    for i, t in enumerate(tracks):
+        track_headers.append({"index": i, "name": t.name})
+
+    scene_headers = []
+    for i, s in enumerate(scenes):
+        scene_headers.append({
+            "index": i,
+            "name": s.name,
+            "tempo": s.tempo if s.tempo > 0 else None,
+        })
+
+    matrix = []
+    for si, scene in enumerate(scenes):
+        row = []
+        for ti, track in enumerate(tracks):
+            slots = list(track.clip_slots)
+            if si >= len(slots):
+                row.append({"state": "missing"})
+                continue
+            slot = slots[si]
+            cell = {"state": "empty"}
+            if slot.has_clip and slot.clip:
+                clip = slot.clip
+                if clip.is_recording:
+                    cell["state"] = "recording"
+                elif clip.is_playing:
+                    cell["state"] = "playing"
+                elif clip.is_triggered:
+                    cell["state"] = "triggered"
+                else:
+                    cell["state"] = "stopped"
+                cell["name"] = clip.name
+                cell["color_index"] = clip.color_index
+            row.append(cell)
+        matrix.append(row)
+
+    return {
+        "tracks": track_headers,
+        "scenes": scene_headers,
+        "matrix": matrix,
+    }
+
+
+@register("fire_scene_clips")
+def fire_scene_clips(song, params):
+    """Fire a scene with optional track filter."""
+    scene_index = int(params["scene_index"])
+    track_indices = params.get("track_indices")
+
+    scene = get_scene(song, scene_index)
+
+    if track_indices is None:
+        # Fire entire scene
+        scene.fire()
+        return {"scene_index": scene_index, "fired": "all"}
+
+    # Fire specific tracks only
+    tracks = list(song.tracks)
+    fired = []
+    for ti in track_indices:
+        ti = int(ti)
+        if ti < 0 or ti >= len(tracks):
+            raise IndexError("Track index %d out of range (0..%d)" % (ti, len(tracks) - 1))
+        slots = list(tracks[ti].clip_slots)
+        if scene_index < len(slots):
+            slots[scene_index].fire()
+            fired.append(ti)
+
+    return {"scene_index": scene_index, "fired_tracks": fired}
+
+
+@register("stop_all_clips")
+def stop_all_clips(song, params):
+    """Stop all playing clips in the session."""
+    song.stop_all_clips()
+    return {"stopped": True}
+
+
+@register("get_playing_clips")
+def get_playing_clips(song, params):
+    """Return all currently playing or triggered clips."""
+    tracks = list(song.tracks)
+    clips = []
+    for ti, track in enumerate(tracks):
+        for si, slot in enumerate(track.clip_slots):
+            if slot.has_clip and slot.clip:
+                clip = slot.clip
+                if clip.is_playing or clip.is_triggered:
+                    clips.append({
+                        "track_index": ti,
+                        "track_name": track.name,
+                        "clip_index": si,
+                        "clip_name": clip.name,
+                        "is_playing": clip.is_playing,
+                        "is_triggered": clip.is_triggered,
+                    })
+    return {"clips": clips}

package/remote_script/LivePilot/server.py

@@ -39,6 +39,9 @@ WRITE_COMMANDS = frozenset([
     # scenes
     "create_scene", "delete_scene", "duplicate_scene", "fire_scene",
     "set_scene_name", "set_scene_color", "set_scene_tempo",
+    "fire_scene_clips", "stop_all_clips",
+    # tracks (freeze/flatten)
+    "freeze_track", "flatten_track",
     # mixing
     "set_track_volume", "set_track_pan", "set_track_send",
     "set_master_volume", "set_track_routing",
@@ -57,6 +60,11 @@ WRITE_COMMANDS = frozenset([
     "clear_clip_automation",
 ])
 
+# Commands that need longer timeouts (e.g., freeze renders audio)
+SLOW_WRITE_COMMANDS = frozenset([
+    "freeze_track",
+])
+
 
 class LivePilotServer(object):
     """TCP server that bridges JSON commands to Ableton's main thread.
@@ -212,9 +220,14 @@ class LivePilotServer(object):
         request_id = command.get("id", "unknown")
         cmd_type = command.get("type", "")
 
-        # Determine timeout based on read vs write
+        # Determine timeout based on read vs write vs slow write
         is_write = cmd_type in WRITE_COMMANDS
-        timeout = 15 if is_write else 10
+        if cmd_type in SLOW_WRITE_COMMANDS:
+            timeout = 35
+        elif is_write:
+            timeout = 15
+        else:
+            timeout = 10
 
         # Per-command response queue
         response_queue = queue.Queue()