livepilot 1.10.8 → 1.12.2

package/mcp_server/tools/_motif_engine.py

@@ -201,24 +201,39 @@ def detect_motifs(
         salience = _score_salience(pattern, len(occurrences), total_note_count)
         fatigue = _score_fatigue(len(occurrences), total_bars)
 
-        # Get representative pitches from first occurrence
+        # Get representative pitches + inter-onset intervals from first occurrence.
+        # Rhythm is the list of start_time deltas between successive notes in
+        # the pattern window; until v1.10.9 this field was left empty with a
+        # "TODO: Phase 3" marker, which is what forced Hook Hunter's rhythm
+        # side to fall back to drum-track-name regex. Populating it here lets
+        # downstream code actually reason about rhythmic distinctiveness.
         first_occ = occurrences[0] if occurrences else {}
         first_track = first_occ.get("track", 0)
         first_pos = first_occ.get("start_position", 0)
-        rep_pitches = []
+        rep_pitches: list[int] = []
+        rhythm_intervals: list[float] = []
         if first_track in notes_by_track:
             sorted_notes = sorted(notes_by_track[first_track],
                                   key=lambda n: n.get("start_time", 0))
+            span = min(len(pattern) + 1, len(sorted_notes) - first_pos)
             rep_pitches = [
                 sorted_notes[first_pos + j].get("pitch", 60)
-                for j in range(min(len(pattern) + 1, len(sorted_notes) - first_pos))
+                for j in range(span)
+            ]
+            rhythm_intervals = [
+                round(
+                    float(sorted_notes[first_pos + j + 1].get("start_time", 0.0))
+                    - float(sorted_notes[first_pos + j].get("start_time", 0.0)),
+                    4,
+                )
+                for j in range(span - 1)
             ]
 
         motif = MotifUnit(
             motif_id=f"motif_{len(motifs):03d}",
             kind="melodic" if any(abs(i) > 0 for i in pattern) else "rhythmic",
             intervals=list(pattern),
-            rhythm=[],  # TODO: rhythm detection in Phase 3
+            rhythm=rhythm_intervals,
             representative_pitches=rep_pitches,
             occurrences=occurrences,
             salience=salience,

package/mcp_server/tools/analyzer.py

@@ -2,88 +2,66 @@
 
 30 tools requiring the LivePilot Analyzer M4L device on the master track.
 These tools are optional — all core tools work without the device.
+
+Helpers live in ``_analyzer_engine/`` (context accessors, Simpler
+post-load hygiene, FluCoMa hint formatting). This file contains the
+``@mcp.tool()`` surface only — keeping decorator order stable was
+important for BUG-C1's refactor.
 """
 
 from __future__ import annotations
 
 import logging
 import os
-import re  # used below in filename parsing helpers
 from typing import Optional
 
 from fastmcp import Context
 
 from ..server import mcp, _identify_port_holder
+from ._analyzer_engine import (
+    PITCH_NAMES,
+    _filename_stem,
+    _flucoma_hint,
+    _get_m4l,
+    _get_spectral,
+    _is_warped_loop,
+    _require_analyzer,
+    _simpler_post_load_hygiene,
+)
 
-# Logger must be defined before any helper that uses it — _require_analyzer
-# below calls logger.debug on an exception path, so defining the logger later
-# in the file risked NameError under unusual import orderings.
 logger = logging.getLogger(__name__)
 
 CAPTURE_DIR = os.path.expanduser("~/Documents/LivePilot/captures")
 
 
-def _get_spectral(ctx: Context):
-    """Get SpectralCache from lifespan context."""
-    cache = ctx.lifespan_context.get("spectral")
-    if not cache:
-        raise ValueError("Spectral cache not initialized — restart the MCP server")
-    # Keep the active request context attached so analyzer error paths can
-    # distinguish "device missing" from "bridge disconnected".
-    setattr(cache, "_livepilot_ctx", ctx)
-    return cache
-
+# Live 12 Simpler Slice mode maps slice N to MIDI pitch 36+N (C1 base).
+# This is NOT exposed by the Remote Script API and is a common source of
+# silent audio bugs (BUG-F2). See feedback_analyze_slices_before_programming
+# memory for context.
+SIMPLER_SLICE_BASE_PITCH = 36
 
-def _get_m4l(ctx: Context):
-    """Get M4LBridge from lifespan context."""
-    bridge = ctx.lifespan_context.get("m4l")
-    if not bridge:
-        raise ValueError("M4L bridge not initialized — restart the MCP server")
-    return bridge
 
+def _enrich_slice_response(response: Optional[dict]) -> Optional[dict]:
+    """Add base_midi_pitch field + per-slice midi_pitch to bridge response (BUG-F2).
 
-def _require_analyzer(cache) -> None:
-    """Raise a helpful error if the analyzer is not connected."""
-    if not cache.is_connected:
-        ctx = getattr(cache, "_livepilot_ctx", None)
-        try:
-            track = (
-                ctx.lifespan_context["ableton"].send_command("get_master_track")
-                if ctx else {}
-            )
-        except Exception as exc:
-            logger.debug("_require_analyzer failed: %s", exc)
-            track = {}
-
-        devices = track.get("devices", []) if isinstance(track, dict) else []
-        analyzer_loaded = False
-        for device in devices:
-            normalized = " ".join(
-                str(device.get("name") or "").replace("_", " ").replace("-", " ").lower().split()
-            )
-            if normalized == "livepilot analyzer":
-                analyzer_loaded = True
-                break
-
-        if analyzer_loaded:
-            holder = _identify_port_holder(9880)
-            detail = (
-                "LivePilot Analyzer is loaded on the master track, but its UDP bridge is not connected. "
-            )
-            if holder:
-                detail += (
-                    "UDP port 9880 is currently held by another LivePilot instance "
-                    f"({holder}). Close the other client/server, then retry."
-                )
-            else:
-                detail += "Reload the analyzer device or restart the MCP server."
-            raise ValueError(detail)
-
-        raise ValueError(
-            "LivePilot Analyzer not detected. "
-            "Drag 'LivePilot Analyzer' onto the master track from "
-            "Audio Effects > Max Audio Effect."
-        )
+    The Remote Script returns slice indices only. Users then have to know
+    that slice N plays at MIDI pitch 36+N — a fact that's undocumented in
+    both Ableton's and LivePilot's public API. This enrichment makes the
+    mapping explicit so MIDI pattern generation doesn't silently produce
+    out-of-range notes.
+    """
+    if response is None:
+        return None
+    enriched = dict(response)
+    enriched["base_midi_pitch"] = SIMPLER_SLICE_BASE_PITCH
+    slices = enriched.get("slices") or []
+    # BUG-audit-M2: fall back to positional index when the bridge response
+    # omits the `index` field (protects against bridge version skew).
+    enriched["slices"] = [
+        {**s, "midi_pitch": SIMPLER_SLICE_BASE_PITCH + s.get("index", i)}
+        for i, s in enumerate(slices)
+    ]
+    return enriched
 
 
 @mcp.tool()
@@ -149,11 +127,36 @@ def get_master_spectrum(ctx: Context) -> dict:
     return result
 
 
+def _sanitize_pitch(pitch: Optional[dict]) -> Optional[dict]:
+    """Validate a pitch reading from the M4L analyzer (BUG-F1).
+
+    The polyphonic pitch detector can emit out-of-range MIDI notes
+    (e.g., 319, -50, 128+) when it can't latch onto a single
+    fundamental — typical for dense mixes. The amplitude field is the
+    reliable confidence signal: if the detector was sure of its
+    reading, amplitude is non-zero.
+
+    Returns the original dict if the reading is usable, None otherwise.
+    """
+    if not pitch:
+        return None
+    amplitude = pitch.get("amplitude")
+    midi_note = pitch.get("midi_note")
+    if amplitude is None or amplitude <= 0:
+        return None
+    if midi_note is None or midi_note < 0 or midi_note > 127:
+        return None
+    return pitch
+
+
 @mcp.tool()
 def get_master_rms(ctx: Context) -> dict:
     """Get real-time RMS and peak levels from the master bus.
 
     More accurate than LOM meters — includes true RMS (not just peak hold).
+    Pitch readings are validated: the field is only present when the
+    polyphonic pitch detector produced a reading with non-zero
+    amplitude and a MIDI note in [0, 127] (BUG-F1).
     Requires LivePilot Analyzer on master track.
     """
     cache = _get_spectral(ctx)
@@ -169,9 +172,11 @@ def get_master_rms(ctx: Context) -> dict:
     if peak:
         result["peak"] = peak["value"]
 
-    pitch = cache.get("pitch")
-    if pitch:
-        result["pitch"] = pitch["value"]
+    pitch_entry = cache.get("pitch")
+    if pitch_entry:
+        clean = _sanitize_pitch(pitch_entry.get("value"))
+        if clean is not None:
+            result["pitch"] = clean
 
     return result
 
@@ -305,102 +310,10 @@ async def get_clip_file_path(
 #      S Start=0, S Length=1, S Loop On=1 so the full loop plays in its
 #      musical phrasing. For ONE-SHOTS, leave defaults alone.
 
-_BPM_IN_FILENAME_RE = re.compile(r"(\d{2,3})\s*bpm", re.IGNORECASE)
-
-
-def _is_warped_loop(file_path: str) -> bool:
-    """Return True if the filename contains a BPM marker (likely a tempo-locked loop)."""
-    stem = os.path.splitext(os.path.basename(file_path))[0]
-    return bool(_BPM_IN_FILENAME_RE.search(stem))
-
-
-def _filename_stem(file_path: str) -> str:
-    return os.path.splitext(os.path.basename(file_path))[0]
-
-
-async def _simpler_post_load_hygiene(
-    bridge,
-    ableton,
-    track_index: int,
-    device_index: int,
-    file_path: str,
-) -> dict:
-    """Apply post-load hygiene to a newly loaded Simpler and verify success.
-
-    Steps:
-      1. Read track info to verify the device's actual name matches the
-         expected sample stem. If it doesn't, return an error.
-      2. Set Snap=0 (Off) — required so sample playback works.
-      3. If filename indicates a warped loop, set S Start=0, S Length=1,
-         S Loop On=1 so the loop plays fully instead of being cropped.
-      4. Return a verified response dict.
-    """
-    expected_stem = _filename_stem(file_path)
-
-    # Step 1: verify device name matches expected file
-    try:
-        track_info = ableton.send_command(
-            "get_track_info", {"track_index": track_index}
-        )
-    except Exception as exc:
-        return {"error": f"Verification read failed: {exc}"}
-
-    devices = track_info.get("devices", []) or []
-    if device_index < 0 or device_index >= len(devices):
-        return {
-            "error": (
-                f"Device index {device_index} out of range after load "
-                f"(track has {len(devices)} devices)"
-            ),
-            "verified": False,
-        }
-    device = devices[device_index]
-    actual_name = str(device.get("name") or "")
-    verified = expected_stem in actual_name or actual_name in expected_stem
-    if not verified:
-        return {
-            "error": (
-                f"Sample verification FAILED — Simpler name '{actual_name}' "
-                f"does not match requested file '{expected_stem}'. The bridge "
-                f"reported success but the actual sample is different. "
-                f"Try `load_browser_item` with a user_library URI instead."
-            ),
-            "verified": False,
-            "actual_device_name": actual_name,
-            "expected_stem": expected_stem,
-        }
-
-    # Step 2: turn Snap OFF — required for reliable playback after replace
-    hygiene_params: list[dict] = [
-        {"name_or_index": "Snap", "value": 0},
-    ]
-
-    # Step 3: smart defaults for warped loops
-    if _is_warped_loop(file_path):
-        hygiene_params.extend([
-            {"name_or_index": "S Start", "value": 0.0},
-            {"name_or_index": "S Length", "value": 1.0},
-            {"name_or_index": "S Loop On", "value": 1},
-        ])
-
-    try:
-        ableton.send_command("batch_set_parameters", {
-            "track_index": track_index,
-            "device_index": device_index,
-            "parameters": hygiene_params,
-        })
-    except Exception as exc:
-        logger.debug("_simpler_post_load_hygiene failed: %s", exc)
-        # non-fatal — verification already succeeded
-        pass
-
-    return {
-        "verified": True,
-        "device_name": actual_name,
-        "track_index": track_index,
-        "device_index": device_index,
-        "warped_loop_defaults_applied": _is_warped_loop(file_path),
-    }
+# _BPM_IN_FILENAME_RE, _is_warped_loop, _filename_stem, and the
+# _simpler_post_load_hygiene coroutine now live in
+# ``_analyzer_engine/sample.py`` — re-exported via this module's imports
+# at the top of the file so tests importing them by name still resolve.
 
 
 @mcp.tool()
@@ -558,15 +471,138 @@ async def get_simpler_slices(
 ) -> dict:
     """Get slice point positions from a Simpler device.
 
-    Returns each slice's position in frames and seconds, plus sample metadata
-    (sample rate, length, playback mode). Use this to understand the rhythmic
-    structure of a sliced sample and program MIDI patterns targeting slices.
+    Returns each slice's position in frames and seconds, the MIDI pitch
+    that triggers it (slice 0 = C1 / MIDI 36, slice 1 = C#1 / MIDI 37, etc.
+    per BUG-F2), plus sample metadata (sample rate, length, playback mode).
+
+    **Always use the returned `midi_pitch` when programming MIDI notes to
+    trigger slices.** The Live 12 Simpler Slice-mode base note is C1,
+    NOT C3 — writing notes at pitch 60+ on a sample with <24 slices
+    triggers nothing and produces silent output.
+
+    Use this to understand the rhythmic structure of a sliced sample
+    and program MIDI patterns targeting slices. Requires LivePilot
+    Analyzer on master track.
+    """
+    cache = _get_spectral(ctx)
+    _require_analyzer(cache)
+    bridge = _get_m4l(ctx)
+    raw = await bridge.send_command("get_simpler_slices", track_index, device_index)
+    return _enrich_slice_response(raw)
+
+
+@mcp.tool()
+async def classify_simpler_slices(
+    ctx: Context,
+    track_index: int,
+    device_index: int = 0,
+    file_path: Optional[str] = None,
+) -> dict:
+    """Classify each Simpler slice as KICK / SNARE / HAT / ghost via FFT analysis.
+
+    Reads slice positions via ``get_simpler_slices``, loads the backing
+    WAV file, and runs 4-band spectral classification on each segment.
+    Returns the enriched slice list with a ``label`` field per entry
+    plus feature breakdown (peak, rms, sub_pct, low_pct, mid_pct,
+    high_pct).
+
+    **Always run this before programming drum patterns on a sliced
+    break.** Slice content depends on transient detection order in the
+    source audio — slice 0 is NOT guaranteed to be a kick. Assuming
+    drum-rack convention produces wrong grooves that take iterations to
+    diagnose (see 2026-04-18 creative session for the canonical case).
+
+    Classification rules (validated on "Break Ghosts 90 bpm"):
+      - KICK: sub+low >= 45%, high < 40%
+      - HAT: high >= 70% AND mid < 25% (thin metal disc = no drum body)
+      - SNARE: mid >= 25% AND high >= 40% AND peak >= 0.6 (broadband loud)
+      - ghost: peak < 0.35
+
+    Parameters:
+      track_index, device_index: the Simpler to analyze
+      file_path: (optional) explicit WAV path. If omitted, attempts
+        lookup via the bridge. Bridge-native resolution is limited in
+        v1.11 — when the sample lives in the Core Library, pass the
+        absolute path explicitly.
+
+    Returns: dict with ``slices`` list. Each slice entry has:
+      index, frame, seconds, midi_pitch (36+index), label, peak, rms,
+      sub_pct, low_pct, mid_pct, high_pct.
+
     Requires LivePilot Analyzer on master track.
     """
+    import soundfile as sf
+
+    from ..sample_engine.slice_classifier import classify_slices
+
     cache = _get_spectral(ctx)
     _require_analyzer(cache)
     bridge = _get_m4l(ctx)
-    return await bridge.send_command("get_simpler_slices", track_index, device_index)
+
+    # 1. Get slice positions
+    raw_slices = await bridge.send_command(
+        "get_simpler_slices", track_index, device_index
+    )
+    enriched = _enrich_slice_response(raw_slices)
+    if enriched is None:
+        return {"error": "Bridge returned no slice data"}
+
+    # 2. Resolve file path
+    wav_path = file_path
+    if not wav_path:
+        try:
+            file_info = await bridge.send_command(
+                "get_simpler_file_path", track_index, device_index
+            )
+            if isinstance(file_info, dict):
+                wav_path = file_info.get("file_path")
+        except Exception:  # noqa: BLE001 — bridge command may not exist yet
+            wav_path = None
+
+    if not wav_path:
+        return {
+            **enriched,
+            "error": (
+                "No file_path available — pass file_path= explicitly. "
+                "Bridge-based lookup for Simpler sample paths is a v1.12 "
+                "follow-up."
+            ),
+        }
+
+    # 3. Load WAV and build frame boundaries
+    try:
+        audio, sr = sf.read(wav_path)
+    except (sf.LibsndfileError, sf.SoundFileError, RuntimeError, OSError) as exc:
+        # BUG-audit-C3: corrupt / missing / non-audio files must return a
+        # structured error dict instead of raising through the MCP framework
+        # (inconsistent with every other tool in this module).
+        return {
+            **enriched,
+            "error": f"Could not load WAV at {wav_path!r}: {exc}",
+        }
+    slices = enriched["slices"]
+    frame_boundaries = [s["frame"] for s in slices] + [len(audio)]
+
+    # 4. Classify
+    classifications = classify_slices(audio, sr, frame_boundaries)
+
+    # 5. Merge classification into each slice entry
+    merged_slices = []
+    for slice_entry, features in zip(slices, classifications):
+        merged_slices.append({
+            **slice_entry,
+            "label": features["label"],
+            "peak": features["peak"],
+            "rms": features["rms"],
+            "sub_pct": features["sub_pct"],
+            "low_pct": features["low_pct"],
+            "mid_pct": features["mid_pct"],
+            "high_pct": features["high_pct"],
+        })
+
+    enriched["slices"] = merged_slices
+    enriched["classifier_version"] = "v1.0"
+    return enriched
 
 
 @mcp.tool()
@@ -847,21 +883,9 @@ async def capture_stop(ctx: Context) -> dict:
     return await bridge.send_command("capture_stop")
 
 # ── Phase 4: FluCoMa Real-Time ───────────────────────────────────────────
-
-PITCH_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
-
-
-def _flucoma_hint(cache) -> str:
-    """Return an error hint if no FluCoMa data has arrived.
-
-    If ANY stream has data, FluCoMa is working and the specific stream just
-    hasn't updated yet — return a 'play audio' hint. If NO streams have data,
-    FluCoMa may not be installed — return an install hint.
-    """
-    for key in ("spectral_shape", "mel_bands", "chroma", "loudness"):
-        if cache.get(key):
-            return "play some audio"
-    return "FluCoMa may not be installed. Install via: npx livepilot --setup-flucoma"
+#
+# PITCH_NAMES + _flucoma_hint now live in ``_analyzer_engine/flucoma.py``
+# and are re-exported via the top-of-file imports for tests/subclassers.
 
 
 @mcp.tool()