livepilot 1.9.24 → 1.10.1

package/mcp_server/composer/prompt_parser.py

@@ -0,0 +1,329 @@
+"""Prompt parser — natural language → structured CompositionIntent.
+
+Extracts genre, mood, tempo, key, descriptors, and explicit element requests
+from free-form text prompts. Pure computation, no I/O.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+# ── Data Model ─────────────────────────────────────────────────────
+
+@dataclass
+class CompositionIntent:
+    """Structured representation of a composition request."""
+
+    genre: str = ""
+    sub_genre: str = ""
+    mood: str = ""
+    tempo: int = 0               # 0 = auto-detect from genre
+    key: str = ""                # "" = auto-pick based on mood
+    descriptors: list[str] = field(default_factory=list)
+    explicit_elements: list[str] = field(default_factory=list)
+    energy: float = 0.5          # 0.0-1.0
+    layer_count: int = 0         # 0 = auto (genre determines)
+    duration_bars: int = 64      # total arrangement length
+
+    def to_dict(self) -> dict:
+        return {
+            "genre": self.genre,
+            "sub_genre": self.sub_genre,
+            "mood": self.mood,
+            "tempo": self.tempo,
+            "key": self.key,
+            "descriptors": self.descriptors,
+            "explicit_elements": self.explicit_elements,
+            "energy": self.energy,
+            "layer_count": self.layer_count,
+            "duration_bars": self.duration_bars,
+        }
+
+
+# ── Genre Defaults ─────────────────────────────────────────────────
+# genre → (default_tempo, default_keys, default_energy, layer_range)
+
+GENRE_DEFAULTS: dict[str, dict] = {
+    "techno": {
+        "tempo": 128, "keys": ["Am", "Cm"], "energy": 0.7,
+        "layers_min": 5, "layers_max": 7,
+    },
+    "house": {
+        "tempo": 124, "keys": ["Cm", "Fm"], "energy": 0.6,
+        "layers_min": 5, "layers_max": 6,
+    },
+    "hip hop": {
+        "tempo": 90, "keys": ["Cm", "Gm"], "energy": 0.5,
+        "layers_min": 4, "layers_max": 6,
+    },
+    "ambient": {
+        "tempo": 80, "keys": ["C", "Am"], "energy": 0.2,
+        "layers_min": 3, "layers_max": 5,
+    },
+    "drum and bass": {
+        "tempo": 174, "keys": ["Am", "Em"], "energy": 0.8,
+        "layers_min": 5, "layers_max": 7,
+    },
+    "trap": {
+        "tempo": 140, "keys": ["Cm", "Bbm"], "energy": 0.6,
+        "layers_min": 4, "layers_max": 6,
+    },
+    "lo-fi": {
+        "tempo": 85, "keys": ["Fm", "Cm"], "energy": 0.3,
+        "layers_min": 3, "layers_max": 5,
+    },
+}
+
+# Aliases that map to canonical genre names
+_GENRE_ALIASES: dict[str, str] = {
+    "dnb": "drum and bass",
+    "d&b": "drum and bass",
+    "jungle": "drum and bass",
+    "lofi": "lo-fi",
+    "lo fi": "lo-fi",
+    "hiphop": "hip hop",
+    "hip-hop": "hip hop",
+    "deep house": "house",
+    "tech house": "house",
+    "acid techno": "techno",
+    "hard techno": "techno",
+    "industrial techno": "techno",
+    "minimal techno": "techno",
+    "detroit techno": "techno",
+    "dub techno": "techno",
+}
+
+
+# ── Mood Mapping ───────────────────────────────────────────────────
+# mood → (energy_range, key_bias_list)
+
+MOOD_MAPPING: dict[str, dict] = {
+    "dark": {
+        "energy_min": 0.4, "energy_max": 0.6,
+        "key_bias": ["Am", "Cm", "Em", "Dm"],
+    },
+    "euphoric": {
+        "energy_min": 0.8, "energy_max": 1.0,
+        "key_bias": ["C", "G", "F", "A"],
+    },
+    "melancholic": {
+        "energy_min": 0.2, "energy_max": 0.4,
+        "key_bias": ["Fm", "Cm", "Dm", "Bbm"],
+    },
+    "aggressive": {
+        "energy_min": 0.8, "energy_max": 0.9,
+        "key_bias": ["Am", "Em", "Bm", "F#m"],
+    },
+    "dreamy": {
+        "energy_min": 0.2, "energy_max": 0.3,
+        "key_bias": ["C", "F", "Bb", "Eb"],
+    },
+    "chill": {
+        "energy_min": 0.2, "energy_max": 0.4,
+        "key_bias": ["Fm", "Cm", "Gm", "Dm"],
+    },
+    "hypnotic": {
+        "energy_min": 0.5, "energy_max": 0.7,
+        "key_bias": ["Am", "Em", "Dm"],
+    },
+    "ethereal": {
+        "energy_min": 0.2, "energy_max": 0.4,
+        "key_bias": ["C", "F", "Ab", "Eb"],
+    },
+    "driving": {
+        "energy_min": 0.7, "energy_max": 0.9,
+        "key_bias": ["Am", "Em", "Cm"],
+    },
+    "warm": {
+        "energy_min": 0.3, "energy_max": 0.5,
+        "key_bias": ["F", "Bb", "Eb", "Ab"],
+    },
+}
+
+
+# ── Sub-genre keywords ─────────────────────────────────────────────
+
+_SUB_GENRE_KEYWORDS: list[str] = [
+    "minimal", "deep", "acid", "industrial", "detroit", "dub",
+    "progressive", "melodic", "hard", "dark", "atmospheric",
+    "organic", "analog", "modular", "breakbeat", "uk garage",
+    "2-step", "drill", "boom bap", "old school", "new wave",
+]
+
+
+# ── Descriptor keywords (adjectives that color the composition) ────
+
+_DESCRIPTOR_KEYWORDS: list[str] = [
+    "industrial", "ghostly", "warm", "cold", "metallic", "organic",
+    "spacious", "intimate", "raw", "polished", "gritty", "clean",
+    "distorted", "saturated", "lush", "sparse", "dense", "airy",
+    "punchy", "soft", "crisp", "muddy", "bright", "muted",
+    "psychedelic", "glitchy", "cinematic", "underground", "futuristic",
+    "retro", "vintage", "modern", "classic", "experimental",
+]
+
+
+# ── Element extraction patterns ────────────────────────────────────
+
+_ELEMENT_PATTERNS: list[tuple[str, str]] = [
+    # (regex_pattern, element_name)
+    (r"\bwith\s+vocals?\b", "vocal"),
+    (r"\bwith\s+strings?\b", "strings"),
+    (r"\badd\s+strings?\b", "strings"),
+    (r"\b808\s*bass\b", "808"),
+    (r"\bwith\s+808\b", "808"),
+    (r"\bwith\s+synth\b", "synth"),
+    (r"\bwith\s+pads?\b", "pad"),
+    (r"\bwith\s+piano\b", "piano"),
+    (r"\bwith\s+guitar\b", "guitar"),
+    (r"\bwith\s+brass\b", "brass"),
+    (r"\bwith\s+horns?\b", "brass"),
+    (r"\bwith\s+(?:fx|effects?)\b", "fx"),
+    (r"\bwith\s+risers?\b", "fx"),
+    (r"\bwith\s+(?:perc|percussion)\b", "percussion"),
+    (r"\bwith\s+textures?\b", "texture"),
+    (r"\bghostly\s+vocals?\b", "vocal"),
+    (r"\bvocal\s+chops?\b", "vocal"),
+    (r"\bvocal\s+stabs?\b", "vocal"),
+    (r"\bsub\s*bass\b", "bass"),
+    (r"\breese\s*bass\b", "bass"),
+    (r"\bamen\s+break\b", "drums"),
+    (r"\bbreakbeat\b", "drums"),
+    (r"\bfoley\b", "texture"),
+    (r"\bfield\s+recordings?\b", "texture"),
+    (r"\batmospheric\b", "texture"),
+]
+
+
+# ── Regex helpers ──────────────────────────────────────────────────
+
+_TEMPO_RE = re.compile(r"\b(\d{2,3})\s*bpm\b", re.IGNORECASE)
+
+# Key patterns: C, Cm, C#, C# minor, Db, Dbm, F# minor, Bb major
+_KEY_RE = re.compile(
+    r"\b([A-Ga-g][#b]?)\s*(minor|major|min|maj|m)?\b"
+)
+
+
+# ── Parser ─────────────────────────────────────────────────────────
+
+def parse_prompt(text: str) -> CompositionIntent:
+    """Parse a natural language composition prompt into structured intent.
+
+    Examples:
+        "dark minimal techno 128bpm Cm"
+        "euphoric deep house with vocals"
+        "lo-fi hip hop 85bpm F minor dreamy"
+        "aggressive drum and bass 174bpm Am"
+    """
+    intent = CompositionIntent()
+    text_lower = text.lower().strip()
+
+    # 1. Extract tempo
+    tempo_match = _TEMPO_RE.search(text)
+    if tempo_match:
+        intent.tempo = int(tempo_match.group(1))
+
+    # 2. Extract key (search original text to preserve case)
+    key_match = _KEY_RE.search(text)
+    if key_match:
+        root = key_match.group(1)
+        # Normalize root: uppercase first letter
+        root = root[0].upper() + root[1:] if len(root) > 1 else root.upper()
+        quality = key_match.group(2) or ""
+        quality_lower = quality.lower()
+        if quality_lower in ("minor", "min", "m"):
+            intent.key = f"{root}m"
+        elif quality_lower in ("major", "maj"):
+            intent.key = root
+        else:
+            # Standalone note — check if followed by 'm' in the original
+            intent.key = root
+
+    # 3. Match genre (check aliases first, then canonical names)
+    # Sort by length descending to match longer aliases first
+    all_genres = list(_GENRE_ALIASES.items()) + [
+        (g, g) for g in GENRE_DEFAULTS
+    ]
+    all_genres.sort(key=lambda x: -len(x[0]))
+
+    for alias, canonical in all_genres:
+        if alias in text_lower:
+            intent.genre = canonical
+            # Extract sub-genre from the alias if it differs
+            if alias != canonical and " " in alias:
+                parts = alias.split()
+                for part in parts:
+                    if part != canonical and part in text_lower:
+                        intent.sub_genre = part
+            break
+
+    # 4. Check for sub-genre keywords not caught by alias matching
+    if not intent.sub_genre:
+        for kw in _SUB_GENRE_KEYWORDS:
+            if kw in text_lower and kw != intent.genre:
+                intent.sub_genre = kw
+                break
+
+    # 5. Match mood
+    for mood_name in MOOD_MAPPING:
+        if mood_name in text_lower:
+            intent.mood = mood_name
+            break
+
+    # 6. Extract descriptors
+    for descriptor in _DESCRIPTOR_KEYWORDS:
+        if descriptor in text_lower and descriptor != intent.mood and descriptor != intent.sub_genre:
+            intent.descriptors.append(descriptor)
+
+    # 7. Extract explicit elements
+    seen_elements: set[str] = set()
+    for pattern, element in _ELEMENT_PATTERNS:
+        if re.search(pattern, text_lower) and element not in seen_elements:
+            intent.explicit_elements.append(element)
+            seen_elements.add(element)
+
+    # 8. Apply genre defaults for missing fields
+    genre_info = GENRE_DEFAULTS.get(intent.genre, {})
+
+    if intent.tempo == 0 and genre_info:
+        intent.tempo = genre_info["tempo"]
+
+    if not intent.key:
+        # Use mood bias if available, otherwise genre default
+        if intent.mood and intent.mood in MOOD_MAPPING:
+            intent.key = MOOD_MAPPING[intent.mood]["key_bias"][0]
+        elif genre_info:
+            intent.key = genre_info["keys"][0]
+
+    # 9. Compute energy from mood, fallback to genre
+    if intent.mood and intent.mood in MOOD_MAPPING:
+        mood_info = MOOD_MAPPING[intent.mood]
+        intent.energy = (mood_info["energy_min"] + mood_info["energy_max"]) / 2.0
+    elif genre_info:
+        intent.energy = genre_info["energy"]
+    else:
+        intent.energy = 0.5
+
+    # 10. Determine layer count from genre + energy
+    if intent.layer_count == 0 and genre_info:
+        base_min = genre_info["layers_min"]
+        base_max = genre_info["layers_max"]
+        # Higher energy → more layers
+        energy_factor = intent.energy
+        intent.layer_count = round(
+            base_min + (base_max - base_min) * energy_factor
+        )
+
+    # Fallback defaults
+    if intent.tempo == 0:
+        intent.tempo = 120
+    if not intent.key:
+        intent.key = "Am"
+    if intent.layer_count == 0:
+        intent.layer_count = 5
+
+    return intent

package/mcp_server/composer/sample_resolver.py

@@ -0,0 +1,153 @@
+"""Local-first sample resolution for composer plans.
+
+Moves sample resolution from execution time (where the old pseudo-tool
+_agent_pick_best_sample was supposed to "figure it out") to plan time.
+
+Async because splice_remote downloads real samples over gRPC. Filesystem-only
+callers still work synchronously from an async perspective — the function
+only awaits when it actually has to hit the network.
+
+Returns (local_path, source) where source is one of:
+  'filesystem'    — hit in a provided search_root directory (no network)
+  'splice_local'  — Splice catalog hit that's already downloaded (no credit spend)
+  'splice_remote' — Splice catalog hit that required download (1 credit)
+  'browser'       — Ableton browser match with a local path
+  'unresolved'    — no match; caller drops the layer from the plan and warns
+
+Preference order is fixed: filesystem > splice_local > splice_remote > browser.
+Filesystem wins even if Splice has a faster hit — local files are free.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional, Tuple
+
+from .layer_planner import LayerSpec
+
+
+_AUDIO_EXTENSIONS = (".wav", ".aif", ".aiff", ".flac")
+
+
+def _query_tokens(query: str) -> list[str]:
+    """Return lowercase query tokens meaningful for matching (len > 2)."""
+    return [t.lower() for t in query.split() if len(t) > 2]
+
+
+def _iter_candidates(root: Path):
+    """Yield all audio-format files beneath root."""
+    if not root.exists():
+        return
+    for ext in _AUDIO_EXTENSIONS:
+        yield from root.rglob(f"*{ext}")
+
+
+def _filesystem_match(layer: LayerSpec, search_roots: list[Path]) -> Optional[str]:
+    """First filename-substring match on role or any query token.
+
+    Sync helper — no network, no async needed.
+    """
+    tokens = _query_tokens(layer.search_query)
+    role = layer.role.lower()
+    for root in search_roots:
+        for path in _iter_candidates(Path(root)):
+            name = path.name.lower()
+            if role and role in name:
+                return str(path)
+            if any(tok in name for tok in tokens):
+                return str(path)
+    return None
+
+
+async def _splice_resolve(
+    layer: LayerSpec,
+    splice_client: object,
+    credit_budget: int,
+) -> Tuple[Optional[str], str]:
+    """Query Splice for the layer. Returns (path, source) or (None, 'unresolved').
+
+    Tries local hits first (free), then remote downloads (1 credit each,
+    respecting the hard floor). Stops on first success.
+    """
+    if splice_client is None or not getattr(splice_client, "connected", False):
+        return None, "unresolved"
+
+    try:
+        result = await splice_client.search_samples(
+            query=layer.search_query,
+            per_page=5,
+        )
+    except Exception:
+        return None, "unresolved"
+
+    samples = list(result.samples) if result and hasattr(result, "samples") else []
+    if not samples:
+        return None, "unresolved"
+
+    # 1. Prefer already-local Splice hits (zero credit spend)
+    for sample in samples:
+        lp = getattr(sample, "local_path", "") or ""
+        if lp and Path(lp).exists():
+            return lp, "splice_local"
+
+    # 2. Remote download — respect the credit hard floor
+    for sample in samples:
+        if getattr(sample, "local_path", ""):
+            continue  # already handled above
+        file_hash = getattr(sample, "file_hash", "")
+        if not file_hash:
+            continue
+        try:
+            can, _remaining = await splice_client.can_afford(1, credit_budget)
+            if not can:
+                break  # credit floor hit — stop trying, don't try next sample
+            downloaded = await splice_client.download_sample(file_hash)
+            if downloaded and Path(downloaded).exists():
+                return downloaded, "splice_remote"
+        except Exception:
+            continue  # try next hit
+
+    return None, "unresolved"
+
+
+async def resolve_sample_for_layer(
+    layer: LayerSpec,
+    search_roots: Optional[list] = None,
+    splice_client: object = None,
+    browser_client: object = None,
+    credit_budget: int = 1,
+) -> Tuple[Optional[str], str]:
+    """Resolve a layer's sample to a concrete local file path.
+
+    Preference order: filesystem > splice_local > splice_remote > browser.
+    Unresolved layers return (None, 'unresolved'); callers drop them from
+    the plan and surface a warning.
+
+    search_roots accepts Path or str entries. Missing dirs are silently
+    skipped. None entries are filtered out.
+    """
+    roots = [Path(r) for r in (search_roots or []) if r]
+
+    # 1. Filesystem — always try first, no network
+    fs_hit = _filesystem_match(layer, roots)
+    if fs_hit:
+        return fs_hit, "filesystem"
+
+    # 2 & 3. Splice (local hits + remote download)
+    path, source = await _splice_resolve(layer, splice_client, credit_budget)
+    if path is not None:
+        return path, source
+
+    # 4. Browser (sync, optional)
+    if browser_client is not None:
+        try:
+            search = getattr(browser_client, "search", None)
+            hits = search(layer.search_query, limit=5) if callable(search) else []
+            for hit in hits or []:
+                lp = hit.get("file_path") if isinstance(hit, dict) else None
+                if lp and Path(lp).exists():
+                    return lp, "browser"
+        except Exception:
+            pass
+
+    return None, "unresolved"

package/mcp_server/composer/tools.py

@@ -0,0 +1,211 @@
+"""Composer Engine MCP tools — 3 tools for auto-composition.
+
+compose: full multi-layer composition from text prompt
+augment_with_samples: add layers to existing session
+get_composition_plan: dry run preview
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from fastmcp import Context
+
+from ..server import mcp
+from .prompt_parser import parse_prompt
+from .engine import ComposerEngine
+
+
+# Singleton engine — stateless, safe to reuse
+_engine = ComposerEngine()
+
+
+def _get_search_roots(ctx: Context) -> list:
+    """Pull sample-search roots from ctx (if the server wired any) plus
+    environment fallbacks.
+    """
+    roots = []
+    try:
+        cfg = ctx.lifespan_context.get("sample_search_roots") if hasattr(ctx, "lifespan_context") else None
+        if cfg:
+            roots.extend(cfg)
+    except Exception:
+        pass
+    return roots
+
+
+async def _credit_safety_prelude(splice_client, max_credits: int) -> tuple[int, int | None, list[str]]:
+    """Apply the hard floor / budget trimming rules upfront.
+
+    Returns (adjusted_max_credits, credits_remaining_or_None, warnings).
+    """
+    warnings: list[str] = []
+    credits_remaining: int | None = None
+
+    if splice_client is None or not getattr(splice_client, "connected", False):
+        warnings.append(
+            "Splice not connected. Plan will use browser/filesystem fallback "
+            "for sample search."
+        )
+        return max_credits, None, warnings
+
+    try:
+        info = await splice_client.get_credits()
+        credits_remaining = getattr(info, "credits", None)
+    except Exception:
+        credits_remaining = None
+
+    if credits_remaining is None:
+        return max_credits, None, warnings
+
+    if credits_remaining <= 5:
+        warnings.append(
+            f"Splice credits critically low ({credits_remaining}). "
+            f"Using downloaded samples only."
+        )
+        max_credits = 0
+    elif max_credits > credits_remaining - 5:
+        safe_budget = max(0, credits_remaining - 5)
+        warnings.append(
+            f"Budget capped at {safe_budget} credits "
+            f"(remaining: {credits_remaining}, floor: 5)."
+        )
+        max_credits = safe_budget
+
+    return max_credits, credits_remaining, warnings
+
+
+@mcp.tool()
+async def compose(
+    ctx: Context,
+    prompt: str,
+    max_credits: int = 50,
+    dry_run: bool = False,
+) -> dict:
+    """Plan a full multi-layer composition from a text prompt.
+
+    Parses the prompt into genre/mood/tempo/key, plans layers using role
+    templates, and compiles an executable plan of tool calls. Does NOT
+    execute — returns the plan for the agent to step through.
+
+    prompt: "dark minimal techno 128bpm with industrial textures and ghostly vocals"
+    max_credits: maximum Splice credits budget for the plan (default 50, 0 = downloaded only)
+    dry_run: if True, return the plan without credit checks
+
+    Returns a compiled plan with step-by-step tool calls. The agent
+    executes each step by calling the referenced tools in sequence.
+    """
+    intent = parse_prompt(prompt)
+
+    splice_client = ctx.lifespan_context.get("splice_client") if hasattr(ctx, "lifespan_context") else None
+    search_roots = _get_search_roots(ctx)
+
+    max_credits, credits_remaining, warnings = await _credit_safety_prelude(splice_client, max_credits)
+
+    result = await _engine.compose(
+        intent,
+        dry_run=dry_run,
+        max_credits=max_credits,
+        search_roots=search_roots,
+        splice_client=splice_client,
+    )
+    result.warnings.extend(warnings)
+
+    output = result.to_dict()
+    output["prompt"] = prompt
+
+    if credits_remaining is not None:
+        output["credits_remaining"] = credits_remaining
+        output["credits_budget"] = max_credits
+
+    return output
+
+
+@mcp.tool()
+async def augment_with_samples(
+    ctx: Context,
+    request: str,
+    max_credits: int = 10,
+    max_layers: int = 3,
+) -> dict:
+    """Plan sample-based layers to add to the existing session.
+
+    Parses the request and builds a plan for new tracks with sample
+    search queries, processing techniques, and volume/pan settings.
+    Does NOT execute — returns the plan for the agent to step through.
+
+    request: "add organic textures" or "layer a vocal chop over the verse"
+    max_credits: maximum Splice credits budget for the plan (default 10)
+    max_layers: maximum number of new tracks in the plan (default 3)
+
+    Returns a compiled plan with step-by-step tool calls.
+    """
+    splice_client = ctx.lifespan_context.get("splice_client") if hasattr(ctx, "lifespan_context") else None
+    search_roots = _get_search_roots(ctx)
+
+    max_credits, credits_remaining, warnings = await _credit_safety_prelude(splice_client, max_credits)
+
+    # Pull current session info for tempo context
+    session_context: dict = {}
+    try:
+        ableton = ctx.lifespan_context.get("ableton")
+        if ableton:
+            info = ableton.send_command("get_session_info", {})
+            session_context["tempo"] = info.get("tempo", 120)
+            session_context["track_count"] = info.get("track_count", 0)
+    except Exception:
+        pass
+
+    result = await _engine.augment(
+        request=request,
+        max_credits=max_credits,
+        max_layers=max_layers,
+        search_roots=search_roots,
+        splice_client=splice_client,
+    )
+
+    if session_context.get("tempo"):
+        result.intent.tempo = int(session_context["tempo"])
+
+    result.warnings.extend(warnings)
+
+    output = result.to_dict()
+    output["request"] = request
+
+    if session_context:
+        output["session_context"] = session_context
+    if credits_remaining is not None:
+        output["credits_remaining"] = credits_remaining
+        output["credits_budget"] = max_credits
+
+    return output
+
+
+@mcp.tool()
+async def get_composition_plan(
+    ctx: Context,
+    prompt: str,
+) -> dict:
+    """Preview what compose would do without executing or spending credits.
+
+    Returns the full layer plan with search queries, technique selections,
+    processing chains, and arrangement sections. Use to review before
+    committing to a full composition.
+
+    prompt: "dark minimal techno 128bpm with industrial textures"
+    """
+    intent = parse_prompt(prompt)
+    splice_client = ctx.lifespan_context.get("splice_client") if hasattr(ctx, "lifespan_context") else None
+    search_roots = _get_search_roots(ctx)
+    plan = await _engine.get_plan(
+        intent,
+        search_roots=search_roots,
+        splice_client=splice_client,
+    )
+    plan["prompt"] = prompt
+    plan["note"] = (
+        "This is a dry run. No samples searched or loaded. "
+        "Use compose() to get the full plan with credit checks, "
+        "then step through each tool call in sequence."
+    )
+    return plan