livepilot 1.10.8 → 1.10.9

package/mcp_server/tools/clips.py

@@ -1,10 +1,13 @@
 """Clip MCP tools — info, create, delete, duplicate, fire, stop, properties, warp.
 
-11 tools matching the Remote Script clips domain.
+11 tools matching the Remote Script clips domain, plus a key-consistency
+diagnostic (BUG-D1) that cross-references filename-encoded keys against
+the analyzer-detected session key.
 """
 
 from __future__ import annotations
 
+import re
 from typing import Optional
 
 from fastmcp import Context
@@ -17,6 +20,72 @@ def _get_ableton(ctx: Context):
     return ctx.lifespan_context["ableton"]
 
 
+# ── Key-token parsing (BUG-D1) ─────────────────────────────────────────
+#
+# Splice filenames encode the key as one of:
+#   _D#min   _Dmin   _Dm       → minor
+#   _Dmaj    _DMaj   _D        → major (trailing nothing or just "maj")
+#   _Eb      _Ebmin   _Dbm     → accidentals accepted as # or b
+#
+# We accept any of those forms and emit a canonical (root, mode) tuple.
+
+# Note → semitone offset from C (C=0, C#=1, D=2, ...)
+_NOTE_TO_SEMI = {
+    "c": 0, "c#": 1, "db": 1, "d": 2, "d#": 3, "eb": 3, "e": 4, "fb": 4,
+    "e#": 5, "f": 5, "f#": 6, "gb": 6, "g": 7, "g#": 8, "ab": 8,
+    "a": 9, "a#": 10, "bb": 10, "b": 11, "cb": 11,
+}
+
+# Match the trailing key token in a filename stem (everything before the
+# extension, underscore-delimited). We anchor to the end of the stem so
+# an earlier "D" in the filename (e.g. "Dabrye_...") doesn't match.
+_KEY_RE = re.compile(
+    r"(?P<root>[A-Ga-g][#b]?)(?P<mode>maj|min|m|Maj|Min)?$",
+    flags=re.IGNORECASE,
+)
+
+
+def _parse_key_from_filename(filename: str) -> Optional[dict]:
+    """Extract key info from a Splice-style filename.
+
+    Returns ``{"root": "D#", "mode": "minor", "semi": 3, "token": "D#min"}``
+    or ``None`` if no recognizable key token is present in the final
+    underscore-segment of the filename stem.
+    """
+    if not filename:
+        return None
+    stem = filename.rsplit(".", 1)[0]
+    last = stem.split("_")[-1]
+    match = _KEY_RE.fullmatch(last)
+    if not match:
+        return None
+    root_raw = match.group("root").lower()
+    mode_raw = (match.group("mode") or "").lower()
+    # Normalize the root to lookup form. Canonicalize B# → C, etc. (rare
+    # but possible in hand-named samples).
+    semi = _NOTE_TO_SEMI.get(root_raw)
+    if semi is None:
+        return None
+    # Without an explicit mode suffix, Splice convention defaults to major.
+    mode = "minor" if mode_raw in ("min", "m") else "major"
+    # Canonical display: capitalize root, preserve #/b.
+    root_display = root_raw[0].upper() + root_raw[1:]
+    return {
+        "root": root_display,
+        "mode": mode,
+        "semi": semi,
+        "token": last,
+    }
+
+
+def _key_to_semi(root: str, mode: str = "major") -> Optional[int]:
+    """Convert a session-reported key like ``"D"`` + ``"minor"`` to 0..11 semis."""
+    if not root:
+        return None
+    semi = _NOTE_TO_SEMI.get(root.strip().lower())
+    return semi
+
+
 def _validate_track_index(track_index: int):
     """Validate track index. Must be >= 0 for regular tracks."""
     if track_index < 0:
@@ -265,3 +334,172 @@ def set_clip_warp_mode(
     if warping is not None:
         params["warping"] = warping
     return _get_ableton(ctx).send_command("set_clip_warp_mode", params)
+
+
+@mcp.tool()
+async def check_clip_key_consistency(
+    ctx: Context,
+    track_index: int,
+    clip_index: int,
+) -> dict:
+    """Cross-check a clip's filename-encoded key against the session key (BUG-D1).
+
+    Splice-style sample filenames encode the sample's key (e.g.
+    ``AU_THF2_128_vocal_..._D#min.wav``). This tool parses that token,
+    compares it to the analyzer-detected session key, and — when they
+    disagree — computes the semitone delta needed to realign, returning
+    the exact ``set_clip_pitch(coarse=...)`` call that would correct it.
+
+    Return shape::
+
+        {
+            "track_index": 6,
+            "clip_index": 0,
+            "filename_key": {"root": "D#", "mode": "minor", "token": "D#min"},
+            "session_key": {"root": "D", "mode": "minor"},
+            "status": "mismatch" | "match" | "unknown",
+            "semitone_delta": -1,          # clip needs to shift DOWN 1
+            "recommended_fix": {
+                "tool": "set_clip_pitch",
+                "args": {"track_index": 6, "clip_index": 0, "coarse": -1}
+            },
+            "reason": "Clip is D#min, session is Dm — shift -1 semitone."
+        }
+
+    Returns ``status="unknown"`` (not an error) when:
+      - the clip is MIDI (no audio file path)
+      - the filename has no parseable key token
+      - the analyzer hasn't detected a session key yet
+
+    Requires the M4L bridge for both ``get_clip_file_path`` and
+    ``get_detected_key``. Degrades gracefully without it.
+    """
+    _validate_track_index(track_index)
+    _validate_clip_index(clip_index)
+
+    # 1) Resolve the clip's file path. Relies on the M4L bridge.
+    try:
+        from .analyzer import get_clip_file_path as _get_path
+        # get_clip_file_path is an @mcp.tool, but FastMCP decorators preserve
+        # the underlying function — we can call it directly for composition.
+        path_resp = await _get_path.fn(ctx, track_index, clip_index)
+    except Exception as exc:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "status": "unknown",
+            "reason": f"Could not resolve clip file path: {exc}",
+        }
+    if not isinstance(path_resp, dict) or path_resp.get("error"):
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "status": "unknown",
+            "reason": path_resp.get("error", "No file path available (MIDI clip?)."),
+        }
+    file_path = path_resp.get("path") or path_resp.get("file_path") or ""
+
+    # 2) Parse key token from the filename.
+    import os
+    filename_key = _parse_key_from_filename(os.path.basename(file_path))
+    if filename_key is None:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "status": "unknown",
+            "reason": "Filename has no recognizable key token.",
+        }
+
+    # 3) Query the session-detected key (needs the analyzer).
+    try:
+        from .analyzer import get_detected_key as _get_key
+        key_resp = await _get_key.fn(ctx)
+    except Exception as exc:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "filename_key": filename_key,
+            "status": "unknown",
+            "reason": f"Analyzer unavailable: {exc}",
+        }
+    if not isinstance(key_resp, dict) or key_resp.get("error") or not key_resp.get("key"):
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "filename_key": filename_key,
+            "status": "unknown",
+            "reason": key_resp.get(
+                "error", "Session key not yet detected — play 4-8 bars."
+            ),
+        }
+    session_root = str(key_resp.get("key", ""))
+    session_mode = str(key_resp.get("scale", "major")).lower()
+    session_semi = _key_to_semi(session_root)
+
+    # 4) Classify + compute fix.
+    file_semi = filename_key["semi"]
+    if session_semi is None or file_semi is None:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "filename_key": filename_key,
+            "session_key": {"root": session_root, "mode": session_mode},
+            "status": "unknown",
+            "reason": "Could not resolve semitone offsets for comparison.",
+        }
+
+    if filename_key["mode"] != session_mode:
+        mode_note = (
+            f" (clip is {filename_key['mode']}, session is {session_mode} — "
+            "mode mismatch is often OK for ambient/background use)"
+        )
+    else:
+        mode_note = ""
+
+    if file_semi == session_semi and filename_key["mode"] == session_mode:
+        return {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "file_path": file_path,
+            "filename_key": filename_key,
+            "session_key": {"root": session_root, "mode": session_mode},
+            "status": "match",
+            "semitone_delta": 0,
+            "recommended_fix": None,
+            "reason": "Clip key matches session.",
+        }
+
+    # Semitone delta: how much the clip should shift to align with the
+    # session root. Choose the smaller magnitude (shift up or down).
+    raw_delta = (session_semi - file_semi) % 12
+    if raw_delta > 6:
+        raw_delta -= 12  # prefer the nearer direction (−1 over +11)
+    delta = raw_delta
+
+    return {
+        "track_index": track_index,
+        "clip_index": clip_index,
+        "file_path": file_path,
+        "filename_key": filename_key,
+        "session_key": {"root": session_root, "mode": session_mode},
+        "status": "mismatch",
+        "semitone_delta": delta,
+        "recommended_fix": {
+            "tool": "set_clip_pitch",
+            "args": {
+                "track_index": track_index,
+                "clip_index": clip_index,
+                "coarse": delta,
+            },
+        },
+        "reason": (
+            f"Clip is {filename_key['root']}{filename_key['mode'][:3]}, "
+            f"session is {session_root}{session_mode[:3]} — "
+            f"shift {delta:+d} semitone{'' if abs(delta) == 1 else 's'}."
+            f"{mode_note}"
+        ),
+    }

package/mcp_server/tools/transport.py

@@ -130,6 +130,61 @@ def get_recent_actions(ctx: Context, limit: int = 20) -> dict:
 
 
 @mcp.tool()
-def get_session_diagnostics(ctx: Context) -> dict:
-    """Analyze the session for potential issues: armed tracks, solo/mute leftovers, unnamed tracks, empty clips/scenes, MIDI tracks without instruments. Returns issues with severity (warning/info) and stats."""
-    return _get_ableton(ctx).send_command("get_session_diagnostics")
+async def get_session_diagnostics(ctx: Context, check_clip_keys: bool = False) -> dict:
+    """Analyze the session for potential issues: armed tracks, solo/mute leftovers, unnamed tracks, empty clips/scenes, MIDI tracks without instruments. Returns issues with severity (warning/info) and stats.
+
+    check_clip_keys: when True, also cross-checks every audio clip's
+        filename-encoded key against the detected session key (BUG-D1 scan).
+        Each mismatch appears as a diagnostic entry with the exact
+        set_clip_pitch call that would correct it. Requires the M4L bridge
+        (uses get_clip_file_path + get_detected_key); skipped gracefully if
+        the bridge is unavailable. Off by default because it round-trips
+        the bridge once per audio clip and can add noticeable latency on
+        large sessions.
+    """
+    result = _get_ableton(ctx).send_command("get_session_diagnostics")
+
+    if not check_clip_keys:
+        return result
+    if not isinstance(result, dict):
+        return result
+
+    # Augment with per-clip key-consistency checks. Each mismatch is added
+    # as a diagnostic with severity="warning"; "unknown" results are
+    # skipped so we don't drown the user in "no key detected yet" noise.
+    from .clips import check_clip_key_consistency  # local import to avoid cycles
+
+    audio_mismatches: list[dict] = []
+    session_info = _get_ableton(ctx).send_command("get_session_info")
+    tracks = (session_info or {}).get("tracks", []) if isinstance(session_info, dict) else []
+    for track in tracks:
+        t_idx = track.get("index")
+        if t_idx is None:
+            continue
+        # We don't know which slots hold audio clips without probing, so
+        # iterate the first N scene slots conservatively. A session with
+        # many scenes would benefit from a scene-count cap; 32 is a
+        # reasonable upper bound for typical production sessions.
+        for clip_idx in range(min(32, len(session_info.get("scenes", []) or []) or 8)):
+            try:
+                check = await check_clip_key_consistency.fn(ctx, t_idx, clip_idx)
+            except Exception:  # noqa: BLE001 — any failure means "skip this clip"
+                continue
+            if not isinstance(check, dict):
+                continue
+            if check.get("status") == "mismatch":
+                audio_mismatches.append({
+                    "severity": "warning",
+                    "category": "clip_key_mismatch",
+                    "track_index": t_idx,
+                    "clip_index": clip_idx,
+                    "message": check.get("reason", ""),
+                    "recommended_fix": check.get("recommended_fix"),
+                })
+
+    if audio_mismatches:
+        issues = result.setdefault("issues", [])
+        issues.extend(audio_mismatches)
+        result["clip_key_mismatch_count"] = len(audio_mismatches)
+
+    return result

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.10.8",
+  "version": "1.10.9",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 324 tools, 45 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
+  "description": "Agentic production system for Ableton Live 12 — 325 tools, 45 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,11 +5,12 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.10.8"
+__version__ = "1.10.9"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router
 from .server import LivePilotServer
+from . import utils        # noqa: F401  — shared helpers (get_track, get_device)
 from . import transport    # noqa: F401  — registers transport handlers
 from . import tracks       # noqa: F401  — registers track handlers
 from . import clips        # noqa: F401  — registers clip handlers
@@ -36,10 +37,16 @@ from . import version_detect    # noqa: F401  — version detection
 # @register decorators with the updated code). Result: a Control Surface
 # toggle now behaves like a fresh module reload, so live-editing mixing.py
 # / devices.py / etc. and re-toggling is enough — no Ableton restart.
+#
+# Order matters: utils comes first because every handler imports
+# ``from .utils import get_track, get_device``. If utils isn't reloaded
+# first, those re-imports during ``importlib.reload(devices)`` still
+# resolve to the stale ``utils`` module object in ``sys.modules``.
 
 _FIRST_CREATE_INSTANCE = True
 
 _HANDLER_MODULES = (
+    utils,
     transport, tracks, clips, notes, devices, scenes,
     mixing, browser, arrangement, diagnostics,
     clip_automation, version_detect,

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": "325-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.10.9",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.10.8",
+      "version": "1.10.9",
       "transport": {
         "type": "stdio"
       }