livepilot 1.6.3 → 1.6.5

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 1.6.5 — Drop music21 (March 2026)
+
+**Theory tools rewritten with zero-dependency pure Python engine.**
+
+- Replace music21 (~100MB) with built-in `_theory_engine.py` (~350 lines)
+- Krumhansl-Schmuckler key detection with 7 mode profiles (major, minor, dorian, phrygian, lydian, mixolydian, locrian)
+- All 7 theory tools keep identical APIs and return formats
+- Zero external dependencies — theory tools work on every install
+- 2-3s faster cold start (no music21 import overhead)
+
+## 1.6.4 — Music Theory (March 2026)
+
+**7 new tools (135 -> 142), theory analysis on live MIDI clips.**
+
+### Theory Domain (7 tools)
+- `analyze_harmony` — chord-by-chord Roman numeral analysis of session clips
+- `suggest_next_chord` — theory-valid chord continuations with style presets (common_practice, jazz, modal, pop)
+- `detect_theory_issues` — parallel fifths/octaves, out-of-key notes, voice crossing, unresolved dominants
+- `identify_scale` — Krumhansl-Schmuckler key/mode detection with confidence-ranked alternatives
+- `harmonize_melody` — 2 or 4-voice SATB harmonization with smooth voice leading
+- `generate_countermelody` — species counterpoint (1st or 2nd species) against a melody
+- `transpose_smart` — diatonic or chromatic transposition preserving scale relationships
+
+### Architecture
+- Pure Python `_theory_engine.py`: Krumhansl-Schmuckler key detection, Roman numeral analysis, voice leading checks
+- Chordify bridge: groups notes by quantized beat position (1/32 note grid)
+- Key hint parsing: handles "A minor", "F# major", enharmonic normalization
+
 ## 1.6.3 — Audit Hardening (March 2026)
 
 - Fix: cursor aliasing in M4L bridge `walk_device` — nested rack traversal now reads chain/pad counts before recursion clobbers shared cursors

package/README.md

@@ -12,7 +12,7 @@
 [![GitHub stars](https://img.shields.io/github/stars/dreamrec/LivePilot)](https://github.com/dreamrec/LivePilot/stargazers)
 [![npm](https://img.shields.io/npm/v/livepilot)](https://www.npmjs.com/package/livepilot)
 
-**AI copilot for Ableton Live 12** — 135 MCP tools, a deep device knowledge corpus, real-time audio analysis, and persistent technique memory.
+**AI copilot for Ableton Live 12** — 142 MCP tools, a deep device knowledge corpus, real-time audio analysis, and persistent technique memory.
 
 Most Ableton MCP servers give the AI tools to push buttons. LivePilot gives it three things on top of that:
 
@@ -20,7 +20,7 @@ Most Ableton MCP servers give the AI tools to push buttons. LivePilot gives it t
 - **Perception** — An M4L analyzer that reads the master bus in real-time: 8-band spectrum, RMS/peak metering, pitch tracking, key detection. The AI makes decisions based on what it hears, not just what's configured.
 - **Memory** — A technique library that persists across sessions. The AI remembers how you built that bass sound, what swing you like on hi-hats, which reverb chain worked on vocals. It learns your taste over time.
 
-These three layers sit on top of 135 deterministic MCP tools that cover transport, tracks, clips, MIDI, devices, scenes, mixing, browser, arrangement, and sample manipulation. Every command goes through Ableton's official Live Object Model API — the same interface Ableton's own control surfaces use. Everything is reversible with undo.
+These three layers sit on top of 142 deterministic MCP tools that cover transport, tracks, clips, MIDI, devices, scenes, mixing, browser, arrangement, and sample manipulation. Every command goes through Ableton's official Live Object Model API — the same interface Ableton's own control surfaces use. Everything is reversible with undo.
 
 ---
 
@@ -296,7 +296,7 @@ npx -y github:dreamrec/LivePilot --status
 
 ---
 
-## 135 Tools Across 12 Domains
+## 142 Tools Across 13 Domains
 
 | Domain | Tools | What you can do |
 |--------|:-----:|-----------------|
@@ -312,6 +312,7 @@ npx -y github:dreamrec/LivePilot --status
 | **Automation** | 8 | Clip envelope CRUD, 16-type curve engine, 15 named recipes, spectral-aware suggestions |
 | **Memory** | 8 | Save, recall, replay, and manage production techniques |
 | **Analyzer** | 20 | Real-time spectral analysis, key detection, sample manipulation, warp markers, device introspection (requires M4L device) |
+| **Theory** | 7 | Harmony analysis, Roman numerals, scale identification, chord suggestions, countermelody, SATB harmonization, smart transposition |
 
 <details>
 <summary><strong>Full tool list</strong></summary>
@@ -402,7 +403,7 @@ There are **15+ MCP servers for Ableton Live** as of March 2026. Here's how the
 
 | | [LivePilot](https://github.com/dreamrec/LivePilot) | [AbletonMCP](https://github.com/ahujasid/ableton-mcp) | [MCP Extended](https://github.com/uisato/ableton-mcp-extended) | [Ableton Copilot](https://github.com/xiaolaa2/ableton-copilot-mcp) | [AbletonBridge](https://github.com/hidingwill/AbletonBridge) | [Producer Pal](https://github.com/adamjmurray/producer-pal) |
 |---|:-:|:-:|:-:|:-:|:-:|:-:|
-| **Tools** | 135 | ~20 | ~35 | ~45 | 322 | ~25 |
+| **Tools** | 142 | ~20 | ~35 | ~45 | 322 | ~25 |
 | **Device knowledge** | 280+ devices | -- | -- | -- | -- | -- |
 | **Audio analysis** | Spectrum/RMS/key | -- | -- | -- | Metering | -- |
 | **Technique memory** | Persistent | -- | -- | -- | -- | -- |
@@ -459,7 +460,7 @@ Every server on this list gives the AI tools to control Ableton. LivePilot is th
 
 The practical difference: other servers let the AI set a parameter. LivePilot lets the AI choose the right parameter based on what device is loaded (atlas), verify the result by reading the audio output (analyzer), and remember the technique for next time (memory).
 
-AbletonBridge has more raw tools (322 vs 135). Producer Pal has the easiest install (drag a .amxd). The original AbletonMCP has the community (2.3k stars). LivePilot has the deepest integration — tools that execute, knowledge that informs, perception that verifies, and memory that accumulates.
+AbletonBridge has more raw tools (322 vs 142). Producer Pal has the easiest install (drag a .amxd). The original AbletonMCP has the community (2.3k stars). LivePilot has the deepest integration — tools that execute, knowledge that informs, perception that verifies, and memory that accumulates.
 
 ---
 

package/m4l_device/livepilot_bridge.js

@@ -68,7 +68,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.6.3"});
+            send_response({"ok": true, "version": "1.6.5"});
             break;
         case "get_params":
             cmd_get_params(args);

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.6.3"
+__version__ = "1.6.5"

package/mcp_server/server.py

@@ -56,6 +56,7 @@ from .tools import arrangement  # noqa: F401, E402
 from .tools import memory       # noqa: F401, E402
 from .tools import analyzer     # noqa: F401, E402
 from .tools import automation   # noqa: F401, E402
+from .tools import theory       # noqa: F401, E402
 
 
 # ---------------------------------------------------------------------------

package/mcp_server/tools/_theory_engine.py

@@ -0,0 +1,366 @@
+"""Pure Python music theory engine — zero dependencies.
+
+Replaces music21 for LivePilot's 7 theory tools. Implements:
+Krumhansl-Schmuckler key detection, Roman numeral analysis,
+voice leading checks, chord naming, and scale construction.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from collections import defaultdict
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+
+ENHARMONIC = {
+    'Cb': 'B', 'Db': 'C#', 'Eb': 'D#', 'Fb': 'E', 'Gb': 'F#',
+    'Ab': 'G#', 'Bb': 'A#',
+    'B#': 'C', 'E#': 'F',
+    'Cbb': 'A#', 'Dbb': 'C', 'Ebb': 'D', 'Fbb': 'D#', 'Gbb': 'F',
+    'Abb': 'G', 'Bbb': 'A',
+    'C##': 'D', 'D##': 'E', 'E##': 'F#', 'F##': 'G', 'G##': 'A',
+    'A##': 'B', 'B##': 'C#',
+}
+
+MAJOR_PROFILE = [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88]
+MINOR_PROFILE = [6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17]
+
+DORIAN_PROFILE     = MAJOR_PROFILE[2:] + MAJOR_PROFILE[:2]
+PHRYGIAN_PROFILE   = MAJOR_PROFILE[4:] + MAJOR_PROFILE[:4]
+LYDIAN_PROFILE     = MAJOR_PROFILE[5:] + MAJOR_PROFILE[:5]
+MIXOLYDIAN_PROFILE = MAJOR_PROFILE[7:] + MAJOR_PROFILE[:7]
+LOCRIAN_PROFILE    = MAJOR_PROFILE[11:] + MAJOR_PROFILE[:11]
+
+MODE_PROFILES = {
+    'major': MAJOR_PROFILE, 'minor': MINOR_PROFILE,
+    'dorian': DORIAN_PROFILE, 'phrygian': PHRYGIAN_PROFILE,
+    'lydian': LYDIAN_PROFILE, 'mixolydian': MIXOLYDIAN_PROFILE,
+    'locrian': LOCRIAN_PROFILE,
+}
+
+SCALES = {
+    'major': [0, 2, 4, 5, 7, 9, 11], 'minor': [0, 2, 3, 5, 7, 8, 10],
+    'dorian': [0, 2, 3, 5, 7, 9, 10], 'phrygian': [0, 1, 3, 5, 7, 8, 10],
+    'lydian': [0, 2, 4, 6, 7, 9, 11], 'mixolydian': [0, 2, 4, 5, 7, 9, 10],
+    'locrian': [0, 1, 3, 5, 6, 8, 10],
+}
+
+TRIAD_QUALITIES = {
+    'major':      ['major', 'minor', 'minor', 'major', 'major', 'minor', 'diminished'],
+    'minor':      ['minor', 'diminished', 'major', 'minor', 'minor', 'major', 'major'],
+    'dorian':     ['minor', 'minor', 'major', 'major', 'minor', 'diminished', 'major'],
+    'phrygian':   ['minor', 'major', 'major', 'minor', 'diminished', 'major', 'minor'],
+    'lydian':     ['major', 'major', 'minor', 'diminished', 'major', 'minor', 'minor'],
+    'mixolydian': ['major', 'minor', 'diminished', 'major', 'minor', 'minor', 'major'],
+    'locrian':    ['diminished', 'major', 'minor', 'minor', 'major', 'major', 'minor'],
+}
+
+CHORD_PATTERNS = {
+    (0, 4, 7): 'major triad', (0, 3, 7): 'minor triad',
+    (0, 3, 6): 'diminished triad', (0, 4, 8): 'augmented triad',
+    (0, 2, 7): 'sus2', (0, 5, 7): 'sus4',
+    (0, 4, 7, 11): 'major seventh', (0, 3, 7, 10): 'minor seventh',
+    (0, 4, 7, 10): 'dominant seventh', (0, 3, 6, 9): 'diminished seventh',
+    (0, 3, 6, 10): 'half-diminished seventh',
+}
+
+ROMAN_LABELS = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII']
+
+# ---------------------------------------------------------------------------
+# Functions
+# ---------------------------------------------------------------------------
+
+
+def pitch_name(midi: int) -> str:
+    """MIDI number -> note name. Always sharp spelling."""
+    return NOTE_NAMES[midi % 12] + str(midi // 12 - 1)
+
+
+def parse_key(key_str: str) -> dict:
+    """Parse key string -> {tonic: 0-11, mode: str}."""
+    parts = key_str.strip().split()
+    raw_tonic = parts[0]
+    mode = parts[1].lower() if len(parts) > 1 else 'major'
+
+    # Normalize tonic: capitalize first letter
+    tonic_name = raw_tonic[0].upper() + raw_tonic[1:]
+
+    # Resolve enharmonics
+    if tonic_name in ENHARMONIC:
+        tonic_name = ENHARMONIC[tonic_name]
+
+    if tonic_name not in NOTE_NAMES:
+        raise ValueError(f"Unknown tonic: {tonic_name} (from '{key_str}')")
+
+    return {"tonic": NOTE_NAMES.index(tonic_name), "mode": mode}
+
+
+def get_scale_pitches(tonic: int, mode: str) -> list[int]:
+    """Return pitch classes (0-11) for the scale."""
+    intervals = SCALES.get(mode, SCALES['major'])
+    return [(tonic + iv) % 12 for iv in intervals]
+
+
+def build_chord(degree: int, tonic: int, mode: str) -> dict:
+    """Build triad from scale degree (0-indexed)."""
+    scale = get_scale_pitches(tonic, mode)
+    root = scale[degree % 7]
+    third = scale[(degree + 2) % 7]
+    fifth = scale[(degree + 4) % 7]
+    quality = TRIAD_QUALITIES.get(mode, TRIAD_QUALITIES['major'])[degree % 7]
+    return {
+        "root_pc": root,
+        "pitch_classes": [root, third, fifth],
+        "quality": quality,
+        "root_name": NOTE_NAMES[root],
+    }
+
+
+def _pearson(x: list[float], y: list[float]) -> float:
+    """Pearson correlation coefficient."""
+    n = len(x)
+    mx = sum(x) / n
+    my = sum(y) / n
+    num = sum((xi - mx) * (yi - my) for xi, yi in zip(x, y))
+    dx = math.sqrt(sum((xi - mx) ** 2 for xi in x))
+    dy = math.sqrt(sum((yi - my) ** 2 for yi in y))
+    if dx == 0 or dy == 0:
+        return 0.0
+    return num / (dx * dy)
+
+
+def detect_key(notes: list[dict], mode_detection: bool = True) -> dict:
+    """Krumhansl-Schmuckler key detection."""
+    # Build pitch-class histogram weighted by duration
+    histogram = [0.0] * 12
+    for n in notes:
+        if n.get("mute", False):
+            continue
+        pc = n["pitch"] % 12
+        histogram[pc] += n.get("duration", 1.0)
+
+    profiles = MODE_PROFILES if mode_detection else {
+        'major': MAJOR_PROFILE, 'minor': MINOR_PROFILE,
+    }
+
+    candidates = []
+    for mode_name, profile in profiles.items():
+        for tonic in range(12):
+            rotated = [histogram[(tonic + i) % 12] for i in range(12)]
+            r = _pearson(rotated, profile)
+            candidates.append({
+                "tonic": tonic,
+                "tonic_name": NOTE_NAMES[tonic],
+                "mode": mode_name,
+                "confidence": round(r, 3),
+            })
+
+    candidates.sort(key=lambda c: -c["confidence"])
+    best = candidates[0]
+    return {
+        "tonic": best["tonic"],
+        "tonic_name": best["tonic_name"],
+        "mode": best["mode"],
+        "confidence": best["confidence"],
+        "alternatives": candidates[1:9],
+    }
+
+
+def chord_name(midi_pitches: list[int]) -> str:
+    """Identify chord from MIDI pitches -> 'C-major triad'."""
+    pcs = sorted(set(p % 12 for p in midi_pitches))
+    if not pcs:
+        return "unknown"
+    # Try each pitch class as potential root
+    for root in pcs:
+        intervals = tuple(sorted((pc - root) % 12 for pc in pcs))
+        if intervals in CHORD_PATTERNS:
+            return f"{NOTE_NAMES[root]}-{CHORD_PATTERNS[intervals]}"
+    return f"{NOTE_NAMES[pcs[0]]} chord"
+
+
+def roman_numeral(chord_pcs: list[int], tonic: int, mode: str) -> dict:
+    """Match chord pitch classes -> Roman numeral figure."""
+    pcs_set = set(pc % 12 for pc in chord_pcs)
+    bass_pc = chord_pcs[0] % 12 if chord_pcs else 0
+
+    best = {"figure": "?", "quality": "unknown", "degree": 0,
+            "inversion": 0, "root_name": NOTE_NAMES[tonic]}
+
+    for degree in range(7):
+        triad = build_chord(degree, tonic, mode)
+        triad_set = set(triad["pitch_classes"])
+        if pcs_set == triad_set or pcs_set.issubset(triad_set):
+            quality = triad["quality"]
+            label = ROMAN_LABELS[degree]
+            if quality in ("minor", "diminished"):
+                label = label.lower()
+            if quality == "diminished":
+                label += "\u00b0"
+            # Detect inversion
+            inv = 0
+            if bass_pc != triad["root_pc"]:
+                if bass_pc == triad["pitch_classes"][1]:
+                    inv = 1
+                elif bass_pc == triad["pitch_classes"][2]:
+                    inv = 2
+            best = {"figure": label, "quality": quality, "degree": degree,
+                    "inversion": inv, "root_name": triad["root_name"]}
+            break
+
+    return best
+
+
+def roman_figure_to_pitches(figure: str, tonic: int, mode: str) -> dict:
+    """Parse Roman numeral string -> concrete MIDI pitches.
+
+    Handles: 'IV', 'bVII7', '#ivo7', 'ii7', etc.
+    """
+    remaining = figure
+    chromatic_shift = 0
+    acc_len = 0
+
+    # Parse leading accidentals
+    while remaining and remaining[0] in ('b', '#'):
+        if remaining[0] == 'b':
+            chromatic_shift -= 1
+        else:
+            chromatic_shift += 1
+        remaining = remaining[1:]
+        acc_len += 1
+
+    # Parse Roman numeral
+    upper_remaining = remaining.upper()
+    numeral = ""
+    for rn in ['VII', 'VI', 'IV', 'III', 'II', 'V', 'I']:
+        if upper_remaining.startswith(rn):
+            numeral = rn
+            break
+
+    if not numeral:
+        return {"figure": figure, "error": f"Cannot parse: {figure}"}
+
+    # Detect case of the numeral in original figure
+    numeral_in_orig = remaining[:len(numeral)]
+    is_minor_quality = numeral_in_orig == numeral_in_orig.lower()
+    remaining = remaining[len(numeral):]
+
+    degree = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII'].index(numeral)
+
+    # Build base triad from scale
+    chord = build_chord(degree, tonic, mode)
+    root_pc = (chord["root_pc"] + chromatic_shift) % 12
+
+    # Build pitch classes based on quality
+    if is_minor_quality:
+        pcs = [root_pc, (root_pc + 3) % 12, (root_pc + 7) % 12]
+        quality = "minor"
+    else:
+        # Use scale-derived quality
+        quality = chord["quality"]
+        if quality == "minor":
+            pcs = [root_pc, (root_pc + 3) % 12, (root_pc + 7) % 12]
+        elif quality == "diminished":
+            pcs = [root_pc, (root_pc + 3) % 12, (root_pc + 6) % 12]
+        elif quality == "augmented":
+            pcs = [root_pc, (root_pc + 4) % 12, (root_pc + 8) % 12]
+        else:
+            pcs = [root_pc, (root_pc + 4) % 12, (root_pc + 7) % 12]
+
+    # Handle suffix
+    suffix = remaining.lower()
+    if suffix == "7":
+        seventh = (root_pc + 10) % 12  # dominant/minor 7th
+        pcs.append(seventh)
+        if quality == "minor":
+            quality = "minor seventh"
+        else:
+            quality = "dominant seventh"
+    elif suffix == "o7":
+        seventh = (root_pc + 9) % 12  # diminished 7th
+        pcs.append(seventh)
+        quality = "diminished seventh"
+    elif suffix == "\u00b0":
+        quality = "diminished"
+        pcs = [root_pc, (root_pc + 3) % 12, (root_pc + 6) % 12]
+
+    # Convert to MIDI pitches in octave 4 (root at its natural octave-4 pitch)
+    base_midi = 60 + root_pc
+    midi = []
+    for pc in pcs:
+        p = base_midi + ((pc - root_pc) % 12)
+        midi.append(p)
+
+    return {
+        "figure": figure,
+        "root_pc": root_pc,
+        "pitches": [pitch_name(m) for m in midi],
+        "midi_pitches": midi,
+        "quality": quality,
+    }
+
+
+def check_voice_leading(prev_pitches: list[int], curr_pitches: list[int]) -> list[dict]:
+    """Check voice leading issues between two chords."""
+    issues = []
+    if len(prev_pitches) < 2 or len(curr_pitches) < 2:
+        if len(curr_pitches) >= 2 and curr_pitches[-1] < curr_pitches[0]:
+            issues.append({"type": "voice_crossing"})
+        return issues
+
+    prev_bass, prev_sop = prev_pitches[0], prev_pitches[-1]
+    curr_bass, curr_sop = curr_pitches[0], curr_pitches[-1]
+
+    prev_iv = (prev_sop - prev_bass) % 12
+    curr_iv = (curr_sop - curr_bass) % 12
+
+    bass_moved = prev_bass != curr_bass
+    sop_moved = prev_sop != curr_sop
+    both_moved = bass_moved and sop_moved
+
+    if both_moved and prev_iv == 7 and curr_iv == 7:
+        issues.append({"type": "parallel_fifths"})
+
+    if both_moved and prev_iv % 12 == 0 and curr_iv % 12 == 0:
+        issues.append({"type": "parallel_octaves"})
+
+    if curr_sop < curr_bass:
+        issues.append({"type": "voice_crossing"})
+
+    # Hidden fifth: same direction motion landing on P5
+    if both_moved:
+        bass_dir = curr_bass - prev_bass
+        sop_dir = curr_sop - prev_sop
+        same_dir = (bass_dir > 0 and sop_dir > 0) or (bass_dir < 0 and sop_dir < 0)
+        if same_dir and curr_iv == 7:
+            issues.append({"type": "hidden_fifth"})
+
+    return issues
+
+
+def chordify(notes: list[dict], quant: float = 0.125) -> list[dict]:
+    """Group notes by quantized beat position."""
+    groups: dict[float, list[dict]] = defaultdict(list)
+    for n in notes:
+        if n.get("mute", False):
+            continue
+        q_time = round(n["start_time"] / quant) * quant
+        groups[q_time].append(n)
+
+    result = []
+    for beat in sorted(groups.keys()):
+        group = groups[beat]
+        pitches = sorted(n["pitch"] for n in group)
+        duration = max(max(n["duration"] for n in group), quant)
+        result.append({
+            "beat": round(beat, 4),
+            "duration": round(duration, 4),
+            "pitches": pitches,
+            "pitch_classes": sorted(set(p % 12 for p in pitches)),
+        })
+    return result