livepilot 1.6.5 → 1.7.1

package/mcp_server/tools/midi_io.py

@@ -0,0 +1,305 @@
+"""MIDI file I/O tools — export, import, analyze, piano roll.
+
+4 tools bridging LivePilot's session clips with .mid files.
+Tools 1-2 require Ableton connection. Tools 3-4 are offline-capable.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import statistics
+from pathlib import Path
+from typing import Any, Optional
+
+from fastmcp import Context
+
+from ..server import mcp
+from . import _theory_engine as theory
+
+
+def _get_ableton(ctx: Context):
+    return ctx.lifespan_context["ableton"]
+
+
+def _require_midiutil():
+    try:
+        from midiutil import MIDIFile
+        return MIDIFile
+    except ImportError:
+        raise ImportError(
+            "midiutil is required for MIDI export. "
+            "Install with: pip install midiutil"
+        )
+
+
+def _require_pretty_midi():
+    try:
+        import pretty_midi
+        return pretty_midi
+    except ImportError:
+        raise ImportError(
+            "pretty-midi is required for this tool. "
+            "Install with: pip install pretty-midi"
+        )
+
+
+def _output_dir() -> Path:
+    d = Path.home() / "Documents" / "LivePilot" / "outputs" / "midi"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _validate_midi_path(file_path: str) -> Path:
+    p = Path(file_path)
+    if not p.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+    if p.suffix.lower() not in (".mid", ".midi"):
+        raise ValueError(f"Not a MIDI file: {file_path}")
+    return p
+
+
+# -- Tool 1: export_clip_midi ------------------------------------------------
+
+@mcp.tool()
+def export_clip_midi(
+    ctx: Context,
+    track_index: int,
+    clip_index: int,
+    filename: Optional[str] = None,
+) -> dict:
+    """Export a session clip's notes to a .mid file.
+
+    Fetches notes from the clip and writes them to a standard MIDI file.
+    Auto-generates filename from track/clip if not provided.
+    """
+    MIDIFile = _require_midiutil()
+    ableton = _get_ableton(ctx)
+
+    notes_result = ableton.send_command("get_notes", {
+        "track_index": track_index,
+        "clip_index": clip_index,
+    })
+    notes = notes_result.get("notes", [])
+
+    session = ableton.send_command("get_session_info", {})
+    tempo = float(session.get("tempo", 120.0))
+
+    if not filename:
+        filename = f"track{track_index}_clip{clip_index}.mid"
+    if not filename.endswith((".mid", ".midi")):
+        filename += ".mid"
+
+    out_path = _output_dir() / filename
+
+    midi = MIDIFile(1)
+    midi.addTempo(0, 0, tempo)
+
+    duration_beats = 0.0
+    for n in notes:
+        start = float(n["start_time"])
+        dur = float(n["duration"])
+        pitch = int(n["pitch"])
+        vel = int(n.get("velocity", 100))
+        midi.addNote(0, 0, pitch, start, dur, vel)
+        duration_beats = max(duration_beats, start + dur)
+
+    with open(out_path, "wb") as f:
+        midi.writeFile(f)
+
+    return {
+        "file_path": str(out_path),
+        "note_count": len(notes),
+        "duration_beats": round(duration_beats, 4),
+        "tempo": tempo,
+    }
+
+
+# -- Tool 2: import_midi_to_clip ---------------------------------------------
+
+@mcp.tool()
+def import_midi_to_clip(
+    ctx: Context,
+    file_path: str,
+    track_index: int,
+    clip_index: int,
+    create_clip: bool = True,
+) -> 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.
+    """
+    pretty_midi = _require_pretty_midi()
+    ableton = _get_ableton(ctx)
+
+    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,
+            })
+
+    seen = set()
+    notes = []
+    for n in notes_raw:
+        key = (n["pitch"], round(n["start_time"], 3), round(n["duration"], 3))
+        if key not in seen:
+            seen.add(key)
+            notes.append(n)
+
+    notes = notes[:2000]
+
+    duration_beats = max((n["start_time"] + n["duration"] for n in notes),
+                         default=4.0)
+
+    if create_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", {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "notes": notes,
+        })
+
+    return {
+        "note_count": len(notes),
+        "duration_beats": round(duration_beats, 4),
+        "tempo_source": tempo,
+    }
+
+
+# -- Tool 3: analyze_midi_file -----------------------------------------------
+
+@mcp.tool()
+def analyze_midi_file(
+    ctx: Context,
+    file_path: str,
+) -> dict:
+    """Analyze a .mid file — works offline, no Ableton needed.
+
+    Returns note count, duration, tempo, pitch range, instruments,
+    velocity stats, density curve, and estimated key.
+    """
+    pretty_midi = _require_pretty_midi()
+    path = _validate_midi_path(file_path)
+    pm = pretty_midi.PrettyMIDI(str(path))
+
+    all_notes = []
+    for inst in pm.instruments:
+        for n in inst.notes:
+            all_notes.append(n)
+
+    if not all_notes:
+        return {
+            "note_count": 0,
+            "duration_seconds": round(pm.get_end_time(), 2),
+            "tempo_estimates": list(pm.get_tempo_changes()[1]),
+            "pitch_range": [0, 0],
+            "instruments": [i.name for i in pm.instruments],
+            "velocity_stats": {},
+            "density_curve": [],
+            "key_estimate": "unknown",
+        }
+
+    pitches = [n.pitch for n in all_notes]
+    velocities = [n.velocity for n in all_notes]
+    duration = pm.get_end_time()
+
+    density_curve = []
+    window = 1.0
+    t = 0.0
+    while t < duration:
+        count = sum(1 for n in all_notes if t <= n.start < t + window)
+        density_curve.append({
+            "time": round(t, 1),
+            "density": count / window,
+        })
+        t += window
+
+    notes_for_key = [
+        {"pitch": n.pitch, "duration": n.end - n.start}
+        for n in all_notes
+    ]
+    key_result = theory.detect_key(notes_for_key)
+    key_str = f"{key_result['tonic_name']} {key_result['mode']}"
+
+    vel_stats = {
+        "mean": round(statistics.mean(velocities), 1),
+        "min": min(velocities),
+        "max": max(velocities),
+        "std": round(statistics.stdev(velocities), 1) if len(velocities) > 1 else 0.0,
+    }
+
+    return {
+        "note_count": len(all_notes),
+        "duration_seconds": round(duration, 2),
+        "tempo_estimates": [round(t, 1) for t in pm.get_tempo_changes()[1]],
+        "pitch_range": [min(pitches), max(pitches)],
+        "instruments": [i.name for i in pm.instruments],
+        "velocity_stats": vel_stats,
+        "density_curve": density_curve,
+        "key_estimate": key_str,
+    }
+
+
+# -- Tool 4: extract_piano_roll ----------------------------------------------
+
+@mcp.tool()
+def extract_piano_roll(
+    ctx: Context,
+    file_path: str,
+    resolution: float = 0.125,
+) -> dict:
+    """Extract a 2D piano roll matrix from a .mid file. Offline-capable.
+
+    Returns a velocity matrix [pitch_index][time_step] trimmed to
+    the actual pitch range. Resolution is in beats (0.125 = 32nd note).
+    """
+    pretty_midi = _require_pretty_midi()
+    path = _validate_midi_path(file_path)
+    pm = pretty_midi.PrettyMIDI(str(path))
+
+    tempo_changes = pm.get_tempo_changes()
+    tempo = float(tempo_changes[1][0]) if len(tempo_changes[1]) > 0 else 120.0
+    fs = (tempo / 60.0) / resolution
+
+    roll = pm.get_piano_roll(fs=fs)  # shape (128, T)
+
+    active_pitches = roll.sum(axis=1).nonzero()[0]
+    if len(active_pitches) == 0:
+        return {
+            "piano_roll": [],
+            "pitch_min": 0,
+            "pitch_max": 0,
+            "time_steps": 0,
+            "resolution": resolution,
+        }
+
+    pitch_min = int(active_pitches[0])
+    pitch_max = int(active_pitches[-1])
+    trimmed = roll[pitch_min:pitch_max + 1, :]
+
+    return {
+        "piano_roll": trimmed.astype(int).tolist(),
+        "pitch_min": pitch_min,
+        "pitch_max": pitch_max,
+        "time_steps": int(trimmed.shape[1]),
+        "resolution": resolution,
+    }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.6.5",
+  "version": "1.7.1",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "AI copilot for Ableton Live 12 — 142 tools, device atlas (280+ devices), real-time audio analysis, automation intelligence, and technique memory",
+  "description": "AI copilot for Ableton Live 12 — 155 tools, device atlas (280+ devices), real-time audio analysis, generative algorithms, neo-Riemannian harmony, MIDI file I/O, and technique memory",
   "author": "Pilot Studio",
   "license": "MIT",
   "type": "commonjs",

package/plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "livepilot",
-  "version": "1.6.5",
-  "description": "AI copilot for Ableton Live 12 — 142 tools, device atlas (280+ devices), real-time audio analysis, automation intelligence, and technique memory",
+  "version": "1.7.0",
+  "description": "AI copilot for Ableton Live 12 — 155 tools, device atlas (280+ devices), real-time audio analysis, generative algorithms, neo-Riemannian harmony, MIDI file I/O, and technique memory",
   "author": "Pilot Studio",
   "skills": [
     "skills/livepilot-core",

package/plugin/skills/livepilot-core/SKILL.md

@@ -1,17 +1,17 @@
 ---
 name: livepilot-core
-description: Core discipline for controlling Ableton Live 12 through LivePilot's 142 MCP tools, device atlas (280+ devices), M4L analyzer (spectrum/RMS/key detection), automation intelligence (16 curve types, 15 recipes), music theory analysis, and technique memory. Use whenever working with Ableton Live through MCP tools.
+description: Core discipline for controlling Ableton Live 12 through LivePilot's 155 MCP tools, device atlas (280+ devices), M4L analyzer (spectrum/RMS/key detection), automation intelligence (16 curve types, 15 recipes), music theory analysis, generative algorithms, neo-Riemannian harmony, MIDI file I/O, and technique memory. Use whenever working with Ableton Live through MCP tools.
 ---
 
 # LivePilot Core — Ableton Live 12 AI Copilot
 
-LivePilot is an agentic production system for Ableton Live 12. It combines 142 MCP tools with three layers of intelligence:
+LivePilot is an agentic production system for Ableton Live 12. It combines 155 MCP tools with three layers of intelligence:
 
 - **Device Atlas** — A structured knowledge corpus of 280+ instruments, 139 drum kits, and 350+ impulse responses. Consult the atlas before loading any device. It contains real browser URIs, preset names, and sonic descriptions. Never guess a device name — look it up.
 - **M4L Analyzer** — Real-time audio analysis on the master bus (8-band spectrum, RMS/peak, key detection). Use it to verify mixing decisions, detect frequency problems, and find the key before writing harmonic content.
 - **Technique Memory** — Persistent storage for production decisions. Consult `memory_recall` before creative tasks to understand the user's taste. Save techniques when the user likes something. The memory shapes future decisions without constraining them.
 
-These layers sit on top of 142 deterministic tools across 13 domains: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, arrangement, technique memory, real-time DSP analysis, automation, and music theory.
+These layers sit on top of 155 deterministic tools across 16 domains: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, arrangement, technique memory, real-time DSP analysis, automation, music theory, generative algorithms, neo-Riemannian harmony, and MIDI file I/O.
 
 ## Golden Rules
 
@@ -32,7 +32,7 @@ These layers sit on top of 142 deterministic tools across 13 domains: transport,
 Not all tools respond instantly. Know the tiers and act accordingly.
 
 ### Instant (<1s) — Use freely, no warning needed
-All 142 core tools (transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, automation, theory) plus Layer A perception tools (spectral shape, timbral profile, mel spectrum, chroma, onsets, harmonic/percussive, novelty, momentary loudness). These are the reflex tools — call them anytime without hesitation.
+All 155 core tools (transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, automation, theory, generative, harmony, midi_io) plus Layer A perception tools (spectral shape, timbral profile, mel spectrum, chroma, onsets, harmonic/percussive, novelty, momentary loudness). These are the reflex tools — call them anytime without hesitation.
 
 ### Fast (1-5s) — Use freely, barely noticeable
 `analyze_loudness` · `analyze_dynamic_range` · `compare_loudness`
@@ -117,7 +117,7 @@ Never skip levels. The user's question determines the entry point, but always st
 - MIDI track with no instrument loaded
 - Notes programmed but clip not fired
 
-## Tool Domains (142 total)
+## Tool Domains (155 total)
 
 ### Transport (12)
 `get_session_info` · `set_tempo` · `set_time_signature` · `start_playback` · `stop_playback` · `continue_playback` · `toggle_metronome` · `set_session_loop` · `undo` · `redo` · `get_recent_actions` · `get_session_diagnostics`
@@ -187,6 +187,44 @@ Music theory analysis — built-in pure Python engine, zero external dependencie
 - Use your own musical knowledge alongside these tools — the engine provides data, you provide interpretation
 - Processing time: 2-5s for generative tools (harmonize, countermelody)
 
+### Generative (5)
+Algorithmic composition tools — Euclidean rhythms, minimalist techniques.
+
+**Tools:** `generate_euclidean_rhythm` · `layer_euclidean_rhythms` · `generate_tintinnabuli` · `generate_phase_shift` · `generate_additive_process`
+
+**Key discipline:**
+- All generative tools return note arrays — use `add_notes` to place them in clips
+- `generate_euclidean_rhythm` uses the Bjorklund algorithm and identifies named rhythms (e.g., "tresillo", "cinquillo")
+- `layer_euclidean_rhythms` stacks multiple patterns for polyrhythmic textures across tracks
+- `generate_tintinnabuli` implements Arvo Pärt's technique: a T-voice (triad arpeggio) against a M-voice (melody)
+- `generate_phase_shift` implements Steve Reich's phasing: two identical patterns drifting apart over time
+- `generate_additive_process` implements Philip Glass's technique: melody expanded by adding one note per iteration
+
+### Harmony (4)
+Neo-Riemannian harmony tools — Tonnetz navigation, voice leading, chromatic mediants.
+
+**Tools:** `navigate_tonnetz` · `find_voice_leading_path` · `classify_progression` · `suggest_chromatic_mediants`
+
+**Key discipline:**
+- These tools work with chord names and return harmonic relationships — no clip MIDI required
+- `navigate_tonnetz` returns PRL (Parallel, Relative, Leading-tone) neighbors for any chord
+- `find_voice_leading_path` finds the shortest harmonic path between two chords through Tonnetz space
+- `classify_progression` identifies the neo-Riemannian transform pattern in a chord sequence
+- `suggest_chromatic_mediants` returns all chromatic mediant relations with film score usage notes
+- Opycleid library provides full Tonnetz; falls back to pure Python PRL if not installed
+
+### MIDI I/O (4)
+MIDI file import/export — works with standard .mid files on disk.
+
+**Tools:** `export_clip_midi` · `import_midi_to_clip` · `analyze_midi_file` · `extract_piano_roll`
+
+**Key discipline:**
+- `export_clip_midi` exports a session clip's notes to a .mid file at the specified path
+- `import_midi_to_clip` loads a .mid file into a clip, replacing existing notes
+- `analyze_midi_file` performs offline analysis of any .mid file (tempo, notes, structure) — does not require Ableton connection
+- `extract_piano_roll` returns a 2D velocity matrix (pitch × time) from a .mid file for visualization or processing
+- Dependencies: midiutil (export), pretty-midi (import/analysis) — lazy-loaded, ~5 MB total
+
 ## Workflow: Building a Beat
 
 1. `get_session_info` — check current state
@@ -328,7 +366,7 @@ Deep production knowledge lives in `references/`. Consult these when making crea
 
 | File | What's inside | When to consult |
 |------|--------------|-----------------|
-| `references/overview.md` | All 142 tools mapped with params, units, ranges | Quick lookup for any tool |
+| `references/overview.md` | All 155 tools mapped with params, units, ranges | Quick lookup for any tool |
 | `references/midi-recipes.md` | Drum patterns by genre, chord voicings, scales, hi-hat techniques, humanization, polymetrics | Programming MIDI notes, building beats |
 | `references/sound-design.md` | Stock instruments/effects, parameter recipes for bass/pad/lead/pluck, device chain patterns | Loading and configuring devices |
 | `references/mixing-patterns.md` | Gain staging, parallel compression, sidechain, EQ by instrument, bus processing, stereo width | Setting volumes, panning, adding effects |

package/plugin/skills/livepilot-core/references/overview.md

@@ -1,6 +1,6 @@
-# LivePilot v1.6.5 — Architecture & Tool Reference
+# LivePilot v1.7.0 — Architecture & Tool Reference
 
-LivePilot is an agentic production system for Ableton Live 12. It combines 142 MCP tools with a device knowledge corpus, real-time audio analysis, automation intelligence, and persistent technique memory.
+LivePilot is an agentic production system for Ableton Live 12. It combines 155 MCP tools with a device knowledge corpus, real-time audio analysis, automation intelligence, generative algorithms, neo-Riemannian harmony, MIDI file I/O, and persistent technique memory.
 
 ## Architecture
 
@@ -32,7 +32,7 @@ A flat tool list lets the AI press buttons. LivePilot's three layers give it con
 
 This turns "set EQ band 3 to -4 dB" into "cut 400 Hz by 4 dB, then read the spectrum to confirm the mud is actually reduced."
 
-## The 142 Tools — What Each One Does
+## The 155 Tools — What Each One Does
 
 ### Transport (12) — Playback, tempo, global state, diagnostics
 

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.6.5"
+__version__ = "1.7.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.6.5 initialized")
+        self.log_message("LivePilot v1.7.0 initialized")
         self.show_message("LivePilot: Listening on port 9878")
 
     def disconnect(self):

package/requirements.txt

@@ -1,2 +1,5 @@
 # LivePilot MCP Server dependencies
 fastmcp>=3.0.0,<4.0.0
+midiutil>=1.2.1
+pretty_midi>=0.2.10
+opycleid>=0.5.1