livepilot 1.23.2 → 1.23.4

package/mcp_server/user_corpus/wizard.py

@@ -0,0 +1,224 @@
+"""First-run setup wizard — detects sensible scan candidates on the user's
+filesystem and returns approval prompts the agent (in Claude Code) drives
+through conversation.
+
+The wizard does NOT scan anything. It surveys, returns candidates with
+file counts, and lets the calling agent confirm each with the user before
+adding to the manifest.
+"""
+
+from __future__ import annotations
+
+import platform
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Iterable
+
+
+# ─── Candidate categories the wizard offers ─────────────────────────────────
+
+
+@dataclass
+class WizardCandidate:
+    """One scannable folder the wizard surfaces for approval."""
+    category: str              # "user_library_racks", "max_devices", "plugins", ...
+    suggested_id: str          # e.g. "user-library-racks"
+    type: str                  # scanner type_id
+    path: str
+    file_count: int            # estimated files (capped during enumeration)
+    sample_filenames: list[str]
+    description: str           # 1-2 sentence prompt the agent reads to the user
+    recommended_default: bool  # whether to auto-confirm (false = always ask)
+
+
+def survey_filesystem() -> list[WizardCandidate]:
+    """Inspect the OS-standard locations + return candidates for approval.
+
+    Does not write anything. Caller (skill/agent) walks each candidate and asks
+    the user "scan this? y/n", then calls corpus_add_source for each yes.
+    """
+    candidates: list[WizardCandidate] = []
+    if platform.system() == "Darwin":
+        candidates.extend(_macos_candidates())
+    elif platform.system() == "Windows":
+        candidates.extend(_windows_candidates())
+    else:
+        candidates.extend(_linux_candidates())
+    return [c for c in candidates if c.file_count > 0]
+
+
+def _count_files(root: Path, extensions: Iterable[str], cap: int = 5000) -> tuple[int, list[str]]:
+    """Count files matching any of the extensions under root. Return (count, samples).
+
+    Cap prevents pathological scans during the survey. Caller should still rescan
+    for real (the wizard is just for sizing + showing the user what's there).
+    """
+    if not root.exists():
+        return 0, []
+    exts = tuple(e.lower() for e in extensions)
+    count = 0
+    samples: list[str] = []
+    try:
+        for p in root.rglob("*"):
+            try:
+                if not p.is_file() and not p.is_dir():
+                    continue
+                # Bundle-style "files" (.amxd, .vst3) appear as dirs OR files
+                # depending on OS — count both
+                if p.suffix.lower() in exts:
+                    count += 1
+                    if len(samples) < 5:
+                        samples.append(p.name)
+                    if count >= cap:
+                        break
+            except (PermissionError, OSError):
+                continue
+    except (PermissionError, OSError):
+        pass
+    return count, samples
+
+
+def _macos_candidates() -> list[WizardCandidate]:
+    home = Path.home()
+    out: list[WizardCandidate] = []
+
+    # 1. User Library racks (.adg / .adv)
+    user_lib = home / "Music/Ableton/User Library/Presets"
+    if user_lib.exists():
+        n, samples = _count_files(user_lib, [".adg", ".adv"])
+        if n > 0:
+            out.append(WizardCandidate(
+                category="user_library_racks", suggested_id="user-library-racks",
+                type="adg", path=str(user_lib), file_count=n, sample_filenames=samples,
+                description=(
+                    f"Ableton User Library — {n} rack/effect presets (.adg/.adv). "
+                    "Indexes every saved chain you've made + third-party racks under "
+                    "your User Library. Good first scan."
+                ),
+                recommended_default=True,
+            ))
+
+    # 2. Max for Live devices (.amxd) — multiple plausible locations
+    for label, p in (
+        ("max_for_live_devices", home / "Documents/Max 9/Max for Live Devices"),
+        ("max_for_live_devices_v8", home / "Documents/Max 8/Max for Live Devices"),
+        ("user_library_m4l", home / "Music/Ableton/User Library/MAX MONTY/m4l_2024"),
+        ("user_library_m4l_alt", home / "Music/Ableton/User Library/Presets/Audio Effects/Max Audio Effect"),
+    ):
+        if p.exists():
+            n, samples = _count_files(p, [".amxd"])
+            if n > 0:
+                out.append(WizardCandidate(
+                    category="max_devices", suggested_id=label.replace("_", "-"),
+                    type="amxd", path=str(p), file_count=n, sample_filenames=samples,
+                    description=(
+                        f"Max for Live devices at {p.name} — {n} .amxd files. "
+                        "Captures device type (audio/instrument/midi), Max version, "
+                        "and any Live-exposed parameters."
+                    ),
+                    recommended_default=True,
+                ))
+
+    # 3. Plugin presets (.aupreset / .vstpreset / .fxp / .nksf)
+    for label, p in (
+        ("au_presets", home / "Library/Audio/Presets"),
+        ("vst3_presets", home / "Library/Audio/VST3 Presets"),
+    ):
+        if p.exists():
+            n, samples = _count_files(p, [".aupreset", ".vstpreset", ".fxp", ".fxb", ".nksf"])
+            if n > 0:
+                out.append(WizardCandidate(
+                    category="plugin_presets", suggested_id=label.replace("_", "-"),
+                    type="plugin-preset", path=str(p), file_count=n, sample_filenames=samples,
+                    description=(
+                        f"Plugin presets at {p.name} — {n} preset files. Captures "
+                        "plugin name + vendor + format. Param values are opaque per-plugin "
+                        "binary (same as PluginDevice in .als)."
+                    ),
+                    recommended_default=False,  # often noisy — opt-in
+                ))
+
+    # 4. Sample library (audio files) — .wav/.aif/.flac
+    # Note: corpus has no built-in sample scanner yet; these are advisory.
+    for label, p in (
+        ("apple_loops", Path("/Library/Audio/Apple Loops")),
+        ("user_apple_loops", home / "Library/Audio/Apple Loops"),
+        ("user_samples", home / "Music/Samples"),
+    ):
+        if p.exists():
+            n, _ = _count_files(p, [".wav", ".aif", ".aiff", ".flac"])
+            if n > 0:
+                out.append(WizardCandidate(
+                    category="samples_advisory", suggested_id=label.replace("_", "-"),
+                    type="sample",  # NOTE: scanner not yet implemented
+                    path=str(p), file_count=n, sample_filenames=[],
+                    description=(
+                        f"Sample library at {p.name} — {n} audio files. "
+                        "(Sample scanner is not yet implemented — this is a survey "
+                        "preview only. Skip for now or wait for the next build.)"
+                    ),
+                    recommended_default=False,
+                ))
+
+    # 5. Plugins are NOT a corpus_add_source — they're handled by
+    # corpus_detect_plugins. Surface as a separate "want to detect plugins?" step.
+    return out
+
+
+def _windows_candidates() -> list[WizardCandidate]:
+    home = Path.home()
+    out: list[WizardCandidate] = []
+    user_lib = home / "Documents" / "Ableton" / "User Library" / "Presets"
+    if user_lib.exists():
+        n, samples = _count_files(user_lib, [".adg", ".adv"])
+        if n > 0:
+            out.append(WizardCandidate(
+                category="user_library_racks", suggested_id="user-library-racks",
+                type="adg", path=str(user_lib), file_count=n, sample_filenames=samples,
+                description=f"Ableton User Library racks — {n} .adg/.adv presets.",
+                recommended_default=True,
+            ))
+    return out
+
+
+def _linux_candidates() -> list[WizardCandidate]:
+    return []  # Ableton Live isn't supported on Linux; corpus is mostly empty there
+
+
+# ─── Aggregate decision packet ──────────────────────────────────────────────
+
+
+def build_setup_proposal() -> dict:
+    """Return the full first-run setup proposal: candidates + plugin-detection prompt.
+
+    Caller (skill/agent) walks each item, confirms with user, then dispatches
+    corpus_add_source / corpus_detect_plugins as approved.
+    """
+    candidates = survey_filesystem()
+    return {
+        "candidates": [asdict(c) for c in candidates],
+        "candidate_count": len(candidates),
+        "categories": sorted({c.category for c in candidates}),
+        "plugin_detection_offer": {
+            "prompt": (
+                "Also detect installed VST3/AU/VST2/AAX plugins via "
+                "corpus_detect_plugins? This walks the OS-standard plugin "
+                "folders, parses each bundle's identity metadata, and writes "
+                "_inventory.json. Independent of the file scans above."
+            ),
+            "tool": "corpus_detect_plugins",
+            "recommended_default": True,
+        },
+        "instructions": (
+            "Walk the user through each candidate one at a time. For each, "
+            "summarize file_count + path + description, then ASK 'add this?' "
+            "and only call corpus_add_source on yes. After all candidates are "
+            "decided, ask about plugin_detection_offer separately. Finally "
+            "call corpus_scan() to index everything they approved."
+        ),
+        "do_not_scan": [
+            "Personal .als project folders unless the user explicitly points at one — "
+            "they're sensitive content that the user should opt into per-folder."
+        ],
+        "schema_version": 1,
+    }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.23.2",
+  "version": "1.23.4",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 433 tools, 53 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
+  "description": "Agentic production system for Ableton Live 12 \u2014 453 tools, 54 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "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.23.2"
+__version__ = "1.23.4"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/remote_script/LivePilot/browser.py

@@ -48,8 +48,13 @@ def _navigate_path(browser, path):
     if not parts:
         raise ValueError("Path cannot be empty")
 
-    # First part must be a category name
-    first = parts[0].lower()
+    # First part must be a category name (normalise common aliases first)
+    _path_aliases = {
+        "effects": "audio_effects", "fx": "audio_effects",
+        "audio_fx": "audio_effects", "audiofx": "audio_effects",
+        "midi_fx": "midi_effects", "midifx": "midi_effects",
+    }
+    first = _path_aliases.get(parts[0].lower(), parts[0].lower())
     if first not in categories:
         raise ValueError(
             "Unknown category '%s'. Available: %s"

package/remote_script/LivePilot/devices.py

@@ -618,11 +618,20 @@ def insert_rack_chain(song, params):
         song.end_undo_step()
 
     chain_count = len(list(device.chains))
+    # BUG-2026-04-25: callers (notably add_drum_rack_pad) expect
+    # `chain_index` in the response so they can target the new chain in
+    # subsequent set_drum_chain_note + insert_device calls. Without it,
+    # the caller falls back to chain_index=0 and overwrites/clobbers the
+    # first chain. For position=-1 (append), the new chain lives at
+    # chain_count - 1; for explicit position N (0-indexed), the new
+    # chain lives at N (insert_chain shifts later chains right).
+    new_chain_index = position if 0 <= position < chain_count else chain_count - 1
     result = {
         "inserted": True,
         "track_index": track_index,
         "device_index": device_index,
         "chain_count": chain_count,
+        "chain_index": new_chain_index,
     }
     if assigned_note is not None:
         result["assigned_pad_note"] = assigned_note

package/remote_script/LivePilot/simpler_sample.py

@@ -184,3 +184,101 @@ def replace_sample_native(song, params):
         "method": "native_12_4",
         "live_version": version_string(),
     }
+
+
+@register("get_simpler_file_path")
+def get_simpler_file_path(song, params):
+    """Read the absolute file path of a Simpler's currently-loaded sample.
+
+    Closes the v1.12 follow-up that left ``classify_simpler_slices`` unable
+    to auto-resolve the WAV path: previously the call routed through the
+    M4L bridge ``get_simpler_file_path`` case (added in v1.23.3 JS) but
+    Live's M4L UDP response correlation produced wrong-data on the second
+    successive bridge call (a chunked-response edge case under
+    investigation in the bridge wire protocol). The Remote Script reads
+    ``device.sample.file_path`` directly via Python LOM — no UDP, no Max
+    JS, no chunk reassembly, no ambiguity.
+
+    params dict keys:
+        track_index (int): 0-based index into song.tracks.
+        device_index (int): 0-based index into track.devices.
+        chain_index (int|None): optional, for nested Drum Rack chains.
+        nested_device_index (int|None): optional, position inside the chain.
+
+    Returns on success:
+        file_path (str): absolute filesystem path of the loaded sample.
+        track_index, device_index, chain_index, nested_device_index: echoed.
+        name (str): Simpler device name (typically the sample filename).
+
+    Returns on error:
+        error (str): human-readable message.
+        code (str): STATE_ERROR | INDEX_ERROR | INVALID_PARAM.
+    """
+    try:
+        track_index = int(params["track_index"])
+        device_index = int(params["device_index"])
+    except (KeyError, TypeError, ValueError) as exc:
+        return {
+            "error": "Invalid params: " + str(exc),
+            "code": "INVALID_PARAM",
+        }
+
+    chain_index = params.get("chain_index")
+    nested_device_index = params.get("nested_device_index")
+    if chain_index is not None:
+        try:
+            chain_index = int(chain_index)
+        except (TypeError, ValueError):
+            return {
+                "error": "chain_index must be an integer if provided",
+                "code": "INVALID_PARAM",
+            }
+    if nested_device_index is not None:
+        try:
+            nested_device_index = int(nested_device_index)
+        except (TypeError, ValueError):
+            return {
+                "error": "nested_device_index must be an integer if provided",
+                "code": "INVALID_PARAM",
+            }
+
+    device, err = _resolve_simpler_device(
+        song, track_index, device_index, chain_index, nested_device_index,
+    )
+    if err is not None:
+        return err
+
+    class_name = getattr(device, "class_name", "")
+    if class_name != "OriginalSimpler":
+        return {
+            "error": "Device at resolved path is " + class_name + ", not Simpler",
+            "code": "INVALID_PARAM",
+        }
+
+    sample = getattr(device, "sample", None)
+    if sample is None:
+        return {
+            "error": "Simpler has no sample loaded (device.sample is None)",
+            "code": "STATE_ERROR",
+        }
+
+    file_path = getattr(sample, "file_path", None)
+    if not file_path:
+        return {
+            "error": (
+                "Simpler.sample.file_path is empty — sample may be embedded "
+                "in the Set or otherwise lacks a filesystem path."
+            ),
+            "code": "STATE_ERROR",
+        }
+
+    name = getattr(device, "name", "")
+
+    return {
+        "file_path": str(file_path),
+        "track_index": track_index,
+        "device_index": device_index,
+        "chain_index": chain_index,
+        "nested_device_index": nested_device_index,
+        "name": str(name),
+    }

package/requirements.txt

@@ -1,6 +1,6 @@
 # LivePilot MCP Server dependencies
-numpy>=1.24.0
-fastmcp>=3.0.0,<3.3.0  # pinned upper bound — _get_all_tools() accesses private internals
+numpy>=2.4.4
+fastmcp>=3.2.4,<3.3.0  # pinned upper bound — _get_all_tools() accesses private internals
 midiutil>=1.2.1
 pretty_midi>=0.2.11
 # v1.8 Perception Layer (offline analysis)
@@ -12,7 +12,7 @@ mutagen>=1.47.0
 # Without these, SpliceGRPCClient silently disables itself and search_samples
 # falls back to the SQLite sounds.db which only returns locally downloaded
 # samples (see docs/2026-04-14-bugs-discovered.md — P0-2).
-grpcio>=1.60.0
+grpcio>=1.80.0
 protobuf>=7.34.1
 
 # Development / testing (not required for runtime)

package/server.json

@@ -1,12 +1,12 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "433-tool agentic MCP production system for Ableton Live 12 — 53 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
+  "description": "453-tool agentic MCP production system for Ableton Live 12 \u2014 53 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.23.2",
+  "version": "1.23.4",
   "packages": [
     {
       "registryType": "npm",