livepilot 1.9.23 → 1.10.0

package/mcp_server/atlas/scanner.py

@@ -0,0 +1,236 @@
+"""
+Device Atlas scanner — transforms raw browser scan data into atlas entries.
+
+Converts the flat {categories: {cat: [items]}} payload from scan_browser_deep
+into normalised device dicts ready for enrichment and querying.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+# ── ID generation ────────────────────────────────────────────────────────────
+
+def make_device_id(name: str, prefix: str = "") -> str:
+    """Convert a human-readable device name to a snake_case identifier.
+
+    >>> make_device_id("EQ Eight")
+    'eq_eight'
+    >>> make_device_id("Model D", prefix="auv3_moog")
+    'auv3_moog_model_d'
+    """
+    slug = re.sub(r"[^a-zA-Z0-9]+", "_", name).strip("_").lower()
+    if prefix:
+        prefix_slug = re.sub(r"[^a-zA-Z0-9]+", "_", prefix).strip("_").lower()
+        return f"{prefix_slug}_{slug}"
+    return slug
+
+
+# ── Category / subcategory mapping ───────────────────────────────────────────
+
+_CATEGORY_MAP: dict[str, str] = {
+    "instruments": "instruments",
+    "audio_effects": "audio_effects",
+    "midi_effects": "midi_effects",
+    "drums": "drum_kits",
+    "max_for_live": "max_for_live",
+    "plugins": "plugins",
+    "sounds": "sounds",
+}
+
+_INSTRUMENT_SUBCATEGORIES: dict[str, str] = {
+    # Synths
+    "analog": "synths",
+    "wavetable": "synths",
+    "operator": "synths",
+    "drift": "synths",
+    "meld": "synths",
+    "emit": "synths",
+    "poli": "synths",
+    "tree_tone": "synths",
+    "vector_fm": "synths",
+    "vector_grain": "synths",
+    "bass": "synths",
+    # Physical modelling
+    "collision": "physical_modeling",
+    "tension": "physical_modeling",
+    "electric": "physical_modeling",
+    # Samplers
+    "simpler": "samplers",
+    "sampler": "samplers",
+    # Drums
+    "drum_rack": "drums",
+    "drum_sampler": "drums",
+    "impulse": "drums",
+    # Racks
+    "instrument_rack": "racks",
+    # Routing
+    "external_instrument": "routing",
+    # Granular
+    "granulator_iii": "granular",
+}
+
+_AUDIO_EFFECT_SUBCATEGORIES: dict[str, str] = {
+    # Dynamics
+    "compressor": "dynamics",
+    "glue_compressor": "dynamics",
+    "limiter": "dynamics",
+    "color_limiter": "dynamics",
+    "multiband_dynamics": "dynamics",
+    "gate": "dynamics",
+    "drum_buss": "dynamics",
+    "re_enveloper": "dynamics",
+    # EQ
+    "eq_eight": "eq",
+    "eq_three": "eq",
+    "channel_eq": "eq",
+    # Filter
+    "auto_filter": "filter",
+    "spectral_resonator": "filter",
+    # Delay
+    "delay": "delay",
+    "echo": "delay",
+    "grain_delay": "delay",
+    "filter_delay": "delay",
+    "gated_delay": "delay",
+    "vector_delay": "delay",
+    "beat_repeat": "delay",
+    "spectral_time": "delay",
+    "align_delay": "delay",
+    # Reverb
+    "reverb": "reverb",
+    "hybrid_reverb": "reverb",
+    "convolution_reverb": "reverb",
+    "convolution_reverb_pro": "reverb",
+    # Distortion
+    "saturator": "distortion",
+    "overdrive": "distortion",
+    "pedal": "distortion",
+    "roar": "distortion",
+    "dynamic_tube": "distortion",
+    "erosion": "distortion",
+    "redux": "distortion",
+    "vinyl_distortion": "distortion",
+    "amp": "distortion",
+    "cabinet": "distortion",
+    # Modulation
+    "chorus_ensemble": "modulation",
+    "phaser_flanger": "modulation",
+    "shifter": "modulation",
+    "auto_pan_tremolo": "modulation",
+    "auto_shift": "modulation",
+    "shaper": "modulation",
+    "lfo": "modulation",
+    "envelope_follower": "modulation",
+    "vector_map": "modulation",
+    # Utility
+    "utility": "utility",
+    "spectrum": "utility",
+    "tuner": "utility",
+    "variations": "utility",
+    "prearranger": "utility",
+    # Spatial
+    "surround_panner": "spatial",
+    # Performance
+    "looper": "performance",
+    "arrangement_looper": "performance",
+    "performer": "performance",
+    # Spectral
+    "spectral_blur": "spectral",
+    # Pitch
+    "pitch_hack": "pitch",
+    "pitchloop89": "pitch",
+    # Physical modelling
+    "corpus": "physical_modeling",
+    "resonators": "physical_modeling",
+    # Special
+    "vocoder": "special",
+    # Racks
+    "audio_effect_rack": "racks",
+    # Routing
+    "external_audio_effect": "routing",
+}
+
+
+def _classify_subcategory(device_id: str, category: str) -> str:
+    """Return the subcategory for a device based on its id and category."""
+    if category == "instruments":
+        return _INSTRUMENT_SUBCATEGORIES.get(device_id, "other")
+    if category == "audio_effects":
+        return _AUDIO_EFFECT_SUBCATEGORIES.get(device_id, "other")
+    return "other"
+
+
+# ── Empty device template ────────────────────────────────────────────────────
+
+def _empty_device(
+    device_id: str,
+    name: str,
+    uri: str | None,
+    category: str,
+    subcategory: str,
+    source: str,
+) -> dict[str, Any]:
+    """Return a skeleton device dict with all atlas fields set to defaults."""
+    return {
+        "id": device_id,
+        "name": name,
+        "uri": uri,
+        "category": category,
+        "subcategory": subcategory,
+        "source": source,
+        "enriched": False,
+        "character_tags": [],
+        "use_cases": [],
+        "genre_affinity": {"primary": [], "secondary": []},
+        "self_contained": True,
+        "key_parameters": [],
+        "pairs_well_with": [],
+        "starter_recipes": [],
+        "gotchas": [],
+        "health_flags": [],
+    }
+
+
+# ── Normaliser ───────────────────────────────────────────────────────────────
+
+def normalize_scan_results(raw_scan: dict[str, Any]) -> list[dict[str, Any]]:
+    """Convert raw scan_browser_deep output to a flat list of device dicts.
+
+    Parameters
+    ----------
+    raw_scan : dict
+        ``{"categories": {cat_name: [{"name", "uri", "is_loadable"}, ...], ...}}``
+
+    Returns
+    -------
+    list[dict]
+        Deduplicated device entries with all atlas fields initialised.
+    """
+    categories_data = raw_scan.get("categories", {})
+    seen_uris: set[str] = set()
+    devices: list[dict[str, Any]] = []
+
+    for raw_cat, items in categories_data.items():
+        category = _CATEGORY_MAP.get(raw_cat, raw_cat)
+        source = "native" if raw_cat in _CATEGORY_MAP else raw_cat
+
+        for item in items:
+            name = item.get("name", "")
+            uri = item.get("uri")
+
+            # Deduplicate by URI when available
+            if uri and uri in seen_uris:
+                continue
+            if uri:
+                seen_uris.add(uri)
+
+            device_id = make_device_id(name)
+            subcategory = _classify_subcategory(device_id, category)
+            devices.append(
+                _empty_device(device_id, name, uri, category, subcategory, source)
+            )
+
+    return devices

package/mcp_server/atlas/tools.py

@@ -0,0 +1,224 @@
+"""Atlas MCP tools — search, suggest, compare, and scan the device database.
+
+6 tools for the atlas domain.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+
+from fastmcp import Context
+
+from ..server import mcp
+
+
+def _get_ableton(ctx: Context):
+    return ctx.lifespan_context["ableton"]
+
+
+def _get_atlas():
+    """Get the global AtlasManager instance, loading lazily if needed."""
+    from . import _atlas_instance, _load_atlas
+    if _atlas_instance is None:
+        try:
+            _load_atlas()
+        except FileNotFoundError:
+            return None
+    from . import _atlas_instance as inst
+    return inst
+
+
+@mcp.tool()
+def atlas_search(ctx: Context, query: str, category: str = "all", limit: int = 10) -> dict:
+    """Search the device atlas for instruments, effects, kits, or plugins.
+
+    query:    natural language search — name, sonic character, use case, or genre
+              Examples: "warm analog bass", "reverb", "808 kit", "granular"
+    category: filter by category (all, instruments, audio_effects, midi_effects,
+              max_for_live, drum_kits, plugins)
+    limit:    max results (default 10)
+    """
+    atlas = _get_atlas()
+    if atlas is None:
+        return {"error": "Atlas not loaded. Run scan_full_library first.", "results": []}
+
+    results = atlas.search(query, category=category, limit=limit)
+    return {
+        "query": query,
+        "category": category,
+        "count": len(results),
+        "results": [
+            {
+                "id": r["device"].get("id", ""),
+                "name": r["device"].get("name", ""),
+                "uri": r["device"].get("uri", ""),
+                "category": r["device"].get("category", ""),
+                "sonic_description": r["device"].get("sonic_description", "")[:120],
+                "character_tags": r["device"].get("character_tags", [])[:5],
+                "enriched": r["device"].get("enriched", False),
+                "score": r.get("score", 0),
+            }
+            for r in results
+        ],
+    }
+
+
+@mcp.tool()
+def atlas_device_info(ctx: Context, device_id: str) -> dict:
+    """Get complete atlas knowledge about a device — parameters, recipes, pairings, gotchas.
+
+    device_id: the atlas ID or device name (e.g., "drift", "Compressor", "808_core_kit")
+    """
+    atlas = _get_atlas()
+    if atlas is None:
+        return {"error": "Atlas not loaded. Run scan_full_library first."}
+
+    entry = atlas.lookup(device_id)
+    if entry is None:
+        return {"error": f"Device '{device_id}' not found in atlas", "suggestion": "Use atlas_search to find devices"}
+    return entry
+
+
+@mcp.tool()
+def atlas_suggest(
+    ctx: Context,
+    intent: str,
+    genre: str = "",
+    energy: str = "medium",
+    key: str = "",
+) -> dict:
+    """Suggest devices for a production intent.
+
+    intent: what you're trying to achieve — "warm bass", "crispy hi-hats", "evolving texture"
+    genre:  target genre for better recommendations
+    energy: low/medium/high — affects sonic character suggestions
+    key:    musical key context (e.g., "Cm") for tuned percussion suggestions
+    """
+    atlas = _get_atlas()
+    if atlas is None:
+        return {"error": "Atlas not loaded. Run scan_full_library first."}
+
+    results = atlas.suggest(intent, genre=genre, energy=energy)
+    return {
+        "intent": intent,
+        "genre": genre,
+        "energy": energy,
+        "suggestions": [
+            {
+                "device_id": r["device"]["id"],
+                "device_name": r["device"]["name"],
+                "uri": r["device"].get("uri", ""),
+                "rationale": r["rationale"],
+                "recipe": r.get("recipe"),
+            }
+            for r in results
+        ],
+    }
+
+
+@mcp.tool()
+def atlas_chain_suggest(ctx: Context, role: str, genre: str = "") -> dict:
+    """Suggest a full device chain for a track role.
+
+    role:  the musical role — "bass", "lead", "pad", "drums", "percussion", "texture"
+    genre: target genre for style-appropriate choices
+    """
+    atlas = _get_atlas()
+    if atlas is None:
+        return {"error": "Atlas not loaded. Run scan_full_library first."}
+
+    return atlas.chain_suggest(role, genre=genre)
+
+
+@mcp.tool()
+def atlas_compare(ctx: Context, device_a: str, device_b: str, role: str = "") -> dict:
+    """Compare two devices — strengths, weaknesses, and recommendation for a role.
+
+    device_a: first device name or ID
+    device_b: second device name or ID
+    role:     optional role context (e.g., "bass", "pad")
+    """
+    atlas = _get_atlas()
+    if atlas is None:
+        return {"error": "Atlas not loaded. Run scan_full_library first."}
+
+    return atlas.compare(device_a, device_b, role=role)
+
+
+@mcp.tool()
+def scan_full_library(ctx: Context, force: bool = False) -> dict:
+    """Scan the full Ableton browser and rebuild the device atlas.
+
+    Walks every category (instruments, audio_effects, midi_effects, max_for_live,
+    drums, plugins, packs) and records every loadable item with its URI.
+    Results are merged with curated enrichments and saved to device_atlas.json.
+
+    force: if True, rescan even if atlas already exists (default False)
+    """
+    from .scanner import normalize_scan_results
+    from .enrichments import load_enrichments, merge_enrichments
+    from . import AtlasManager
+
+    atlas_dir = os.path.dirname(os.path.abspath(__file__))
+    atlas_path = os.path.join(atlas_dir, "device_atlas.json")
+    enrichments_dir = os.path.join(atlas_dir, "enrichments")
+
+    if not force and os.path.exists(atlas_path):
+        age = time.time() - os.path.getmtime(atlas_path)
+        if age < 86400:
+            # Reload if not already loaded
+            import mcp_server.atlas as atlas_mod
+            if atlas_mod._atlas_instance is None:
+                atlas_mod._atlas_instance = AtlasManager(atlas_path)
+            return {
+                "status": "already_exists",
+                "age_hours": round(age / 3600, 1),
+                "device_count": atlas_mod._atlas_instance.device_count,
+                "message": "Atlas is recent. Use force=True to rescan.",
+            }
+
+    # Scan browser
+    ableton = _get_ableton(ctx)
+    raw = ableton.send_command("scan_browser_deep", {"max_per_category": 1000})
+
+    # Normalize
+    devices = normalize_scan_results(raw)
+
+    # Load and merge enrichments
+    enrichments = load_enrichments(enrichments_dir)
+    devices = merge_enrichments(devices, enrichments)
+
+    # Count stats
+    stats: dict = {"total_devices": len(devices)}
+    for device in devices:
+        cat = device.get("category", "other")
+        stats[cat] = stats.get(cat, 0) + 1
+    stats["enriched_devices"] = sum(1 for d in devices if d.get("enriched"))
+
+    # Build atlas
+    atlas_data = {
+        "version": "2.0.0",
+        "live_version": "12.3.6",
+        "scanned_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "stats": stats,
+        "devices": devices,
+        "packs": [],
+    }
+
+    # Write
+    with open(atlas_path, "w") as f:
+        json.dump(atlas_data, f, indent=2)
+
+    # Reload into global
+    import mcp_server.atlas as atlas_mod
+    atlas_mod._atlas_instance = AtlasManager(atlas_path)
+
+    return {
+        "status": "scanned",
+        "device_count": len(devices),
+        "enriched_count": stats["enriched_devices"],
+        "stats": stats,
+        "atlas_path": atlas_path,
+    }

package/mcp_server/composer/__init__.py

@@ -0,0 +1 @@
+"""Composer Engine — auto-composition from text prompts via Splice + Sample Engine."""