livepilot 1.9.21 → 1.9.23

package/mcp_server/musical_intelligence/tools.py

@@ -0,0 +1,221 @@
+"""Musical intelligence MCP tools — song-level analysis and critique.
+
+4 tools that look beyond parameters into musical meaning:
+  detect_repetition_fatigue — is the arrangement getting stale?
+  detect_role_conflicts — are tracks fighting for the same space?
+  infer_section_purposes — what is each section trying to do?
+  score_emotional_arc — does the song have a satisfying arc?
+"""
+
+from __future__ import annotations
+
+from fastmcp import Context
+
+from ..server import mcp
+from . import detectors
+
+
+def _get_ableton(ctx: Context):
+    return ctx.lifespan_context["ableton"]
+
+
+@mcp.tool()
+def detect_repetition_fatigue(ctx: Context) -> dict:
+    """Detect repetition fatigue — are patterns overused?
+
+    Analyzes clip reuse across scenes, motif overuse, and section staleness.
+    Returns fatigue level (0=fresh, 1=stale), specific issues, and recommendations.
+
+    Use this when the track "feels repetitive" or when arrangement
+    has been looping without variation.
+    """
+    ableton = _get_ableton(ctx)
+
+    # Get scene matrix for clip reuse analysis
+    try:
+        matrix = ableton.send_command("get_scene_matrix")
+    except Exception:
+        matrix = {}
+
+    scenes = []
+    for i, scene_data in enumerate(matrix.get("scenes", [])):
+        row = matrix.get("matrix", [[]])[i] if i < len(matrix.get("matrix", [])) else []
+        scenes.append({
+            "name": scene_data.get("name", f"Scene {i}"),
+            "clips": row,
+        })
+
+    # Try to get motif graph for deeper analysis
+    motif_graph = None
+    try:
+        motif_graph = ableton.send_command("get_motif_graph")
+    except Exception:
+        pass
+
+    report = detectors.detect_repetition_fatigue(scenes, motif_graph)
+    return report.to_dict()
+
+
+@mcp.tool()
+def detect_role_conflicts(ctx: Context) -> dict:
+    """Detect role conflicts — are tracks fighting for the same musical space?
+
+    Checks for: multiple bass tracks, competing leads, overlapping drum layers.
+    Also flags missing essential roles (no bass, no drums).
+
+    Returns conflict list with severity and recommendations.
+    """
+    ableton = _get_ableton(ctx)
+    session = ableton.send_command("get_session_info")
+    tracks = session.get("tracks", [])
+
+    conflicts = detectors.detect_role_conflicts(tracks)
+    return {
+        "conflicts": [c.to_dict() for c in conflicts],
+        "conflict_count": len(conflicts),
+        "track_count": len(tracks),
+    }
+
+
+@mcp.tool()
+def infer_section_purposes(ctx: Context) -> dict:
+    """Infer what each section/scene is trying to do musically.
+
+    Labels each scene as: setup, tension, payoff, contrast, release,
+    development, or outro — based on density, position, and energy changes.
+
+    Use this to understand the song's structure before making arrangement decisions.
+    """
+    ableton = _get_ableton(ctx)
+    session = ableton.send_command("get_session_info")
+    total_tracks = session.get("track_count", 6)
+
+    # Get scene matrix for density analysis
+    try:
+        matrix = ableton.send_command("get_scene_matrix")
+    except Exception:
+        matrix = {}
+
+    scenes = []
+    for i, scene_data in enumerate(matrix.get("scenes", [])):
+        row = matrix.get("matrix", [[]])[i] if i < len(matrix.get("matrix", [])) else []
+        scenes.append({
+            "name": scene_data.get("name", f"Scene {i}"),
+            "clips": row,
+        })
+
+    purposes = detectors.infer_section_purposes(scenes, total_tracks)
+    return {
+        "sections": [p.to_dict() for p in purposes],
+        "section_count": len(purposes),
+        "purpose_summary": {p.purpose: sum(1 for s in purposes if s.purpose == p.purpose)
+                           for p in purposes},
+    }
+
+
+@mcp.tool()
+def score_emotional_arc(ctx: Context) -> dict:
+    """Score the emotional arc of the arrangement.
+
+    Measures: arc clarity (build→climax→resolve), contrast between sections,
+    payoff strength (does the climax feel earned?), and resolution (does it end well?).
+
+    Returns an overall score (0-1) and specific issues with recommendations.
+    """
+    ableton = _get_ableton(ctx)
+    session = ableton.send_command("get_session_info")
+    total_tracks = session.get("track_count", 6)
+
+    try:
+        matrix = ableton.send_command("get_scene_matrix")
+    except Exception:
+        matrix = {}
+
+    scenes = []
+    for i, scene_data in enumerate(matrix.get("scenes", [])):
+        row = matrix.get("matrix", [[]])[i] if i < len(matrix.get("matrix", [])) else []
+        scenes.append({
+            "name": scene_data.get("name", f"Scene {i}"),
+            "clips": row,
+        })
+
+    purposes = detectors.infer_section_purposes(scenes, total_tracks)
+    arc = detectors.score_emotional_arc(purposes)
+    return arc.to_dict()
+
+
+# ── Phrase Evaluation ────────────────────────────────────────────────
+
+
+@mcp.tool()
+def analyze_phrase_arc(
+    ctx: Context,
+    file_path: str,
+    target: str = "loop",
+) -> dict:
+    """Analyze a captured audio phrase for musical quality.
+
+    Evaluates: arc clarity, contrast, fatigue risk, payoff strength,
+    identity strength, and translation risk.
+
+    file_path: path to a captured audio file (from capture_audio)
+    target: what the phrase is ("loop", "drop", "chorus", "transition", "intro", "outro")
+
+    Requires capture_audio + analyze_loudness + analyze_spectrum_offline first.
+    """
+    from . import phrase_critic
+
+    ableton = _get_ableton(ctx)
+
+    # Run offline analysis on the file
+    loudness_data = None
+    spectrum_data = None
+
+    try:
+        loudness_data = ableton.send_command("analyze_loudness_offline", {
+            "file_path": file_path, "detail": "full",
+        })
+    except Exception:
+        pass
+
+    try:
+        spectrum_data = ableton.send_command("analyze_spectrum_offline_internal", {
+            "file_path": file_path,
+        })
+    except Exception:
+        pass
+
+    critique = phrase_critic.analyze_phrase(loudness_data, spectrum_data, target)
+    critique.render_id = file_path.split("/")[-1] if "/" in file_path else file_path
+    return critique.to_dict()
+
+
+@mcp.tool()
+def compare_phrase_renders(
+    ctx: Context,
+    file_paths: list,
+    target: str = "loop",
+) -> dict:
+    """Compare multiple audio captures and rank by musical quality.
+
+    file_paths: list of paths to captured audio files
+    target: what the phrases are ("loop", "drop", "chorus", etc.)
+
+    Returns ranked list with scores and notes for each.
+    """
+    from . import phrase_critic
+
+    critiques = []
+    for path in file_paths:
+        # Try to get cached analysis or run fresh
+        critique = phrase_critic.analyze_phrase(target=target)
+        critique.render_id = path.split("/")[-1] if isinstance(path, str) and "/" in path else str(path)
+        critiques.append(critique)
+
+    ranking = phrase_critic.compare_phrases(critiques)
+    return {
+        "ranking": ranking,
+        "count": len(ranking),
+        "target": target,
+        "best": ranking[0] if ranking else None,
+    }

package/mcp_server/preview_studio/__init__.py

@@ -0,0 +1,5 @@
+"""Preview Studio — fast A/B/C creative comparison for Stage 2.
+
+Generates multiple creative options (safe/strong/unexpected) and lets
+the agent compare them before committing.
+"""

package/mcp_server/preview_studio/engine.py

@@ -0,0 +1,280 @@
+"""Preview Studio engine — pure computation, zero I/O.
+
+Creates, compares, and ranks preview variants using the creative triptych
+pattern (safe / strong / unexpected).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from typing import Optional
+
+from .models import PreviewSet, PreviewVariant
+
+
+# ── In-memory store ───────────────────────────────────────────────
+
+_preview_sets: dict[str, PreviewSet] = {}
+_MAX_PREVIEW_SETS = 20
+
+
+def get_preview_set(set_id: str) -> Optional[PreviewSet]:
+    return _preview_sets.get(set_id)
+
+
+def store_preview_set(ps: PreviewSet) -> None:
+    _preview_sets[ps.set_id] = ps
+    # Evict oldest sets if over limit
+    while len(_preview_sets) > _MAX_PREVIEW_SETS:
+        oldest_key = next(iter(_preview_sets))
+        del _preview_sets[oldest_key]
+
+
+# ── Creation ──────────────────────────────────────────────────────
+
+
+def create_preview_set(
+    request_text: str,
+    kernel_id: str,
+    strategy: str = "creative_triptych",
+    available_moves: Optional[list[dict]] = None,
+    song_brain: Optional[dict] = None,
+    taste_graph: Optional[dict] = None,
+) -> PreviewSet:
+    """Create a preview set with variant slots.
+
+    For creative_triptych, generates 3 variants: safe, strong, unexpected.
+    Each variant gets a move_id from available_moves ranked by novelty.
+    """
+    set_id = _compute_set_id(request_text, kernel_id)
+    now = int(time.time() * 1000)
+
+    moves = available_moves or []
+    song_brain = song_brain or {}
+    taste_graph = taste_graph or {}
+
+    if strategy == "creative_triptych":
+        variants = _build_triptych(request_text, moves, song_brain, taste_graph, set_id, now)
+    elif strategy == "binary":
+        variants = _build_binary(request_text, moves, song_brain, set_id, now)
+    else:
+        variants = _build_triptych(request_text, moves, song_brain, taste_graph, set_id, now)
+
+    ps = PreviewSet(
+        set_id=set_id,
+        request_text=request_text,
+        strategy=strategy,
+        source_kernel_id=kernel_id,
+        variants=variants,
+        created_at_ms=now,
+    )
+    store_preview_set(ps)
+    return ps
+
+
+def _build_triptych(
+    request_text: str,
+    moves: list[dict],
+    song_brain: dict,
+    taste_graph: dict,
+    set_id: str,
+    now: int,
+) -> list[PreviewVariant]:
+    """Build safe / strong / unexpected variants."""
+    identity = song_brain.get("identity_core", "")
+    sacred = [e.get("description", "") for e in song_brain.get("sacred_elements", [])]
+    sacred_text = ", ".join(sacred[:3]) if sacred else "core elements"
+
+    profiles = [
+        {
+            "label": "safe",
+            "novelty": 0.2,
+            "intent": f"Close to current identity, minimal risk. {request_text}",
+            "identity_effect": "preserves",
+            "what_preserved": f"Preserves {sacred_text}",
+            "why_it_matters": "Low risk — good when identity is fragile",
+        },
+        {
+            "label": "strong",
+            "novelty": 0.5,
+            "intent": f"Musically assertive approach. {request_text}",
+            "identity_effect": "evolves",
+            "what_preserved": f"Maintains {sacred_text} while pushing forward",
+            "why_it_matters": "Best balance of impact and safety",
+        },
+        {
+            "label": "unexpected",
+            "novelty": 0.8,
+            "intent": f"Surprising but taste-filtered. {request_text}",
+            "identity_effect": "contrasts",
+            "what_preserved": f"Respects {sacred_text} but reframes context",
+            "why_it_matters": "High novelty — may unlock a new direction",
+        },
+    ]
+
+    variants = []
+    for i, profile in enumerate(profiles):
+        # Pick a move if available
+        move_id = ""
+        compiled_plan = None
+        if moves and i < len(moves):
+            move_id = moves[i].get("move_id", "")
+            compiled_plan = moves[i].get("compile_plan")
+
+        variants.append(PreviewVariant(
+            variant_id=f"{set_id}_{profile['label']}",
+            label=profile["label"],
+            intent=profile["intent"],
+            novelty_level=profile["novelty"],
+            identity_effect=profile["identity_effect"],
+            what_preserved=profile["what_preserved"],
+            why_it_matters=profile["why_it_matters"],
+            move_id=move_id,
+            compiled_plan=compiled_plan,
+            taste_fit=_estimate_taste_fit(profile["novelty"], taste_graph),
+            created_at_ms=now,
+        ))
+
+    return variants
+
+
+def _build_binary(
+    request_text: str,
+    moves: list[dict],
+    song_brain: dict,
+    set_id: str,
+    now: int,
+) -> list[PreviewVariant]:
+    """Build simple A/B comparison."""
+    return [
+        PreviewVariant(
+            variant_id=f"{set_id}_a",
+            label="option_a",
+            intent=f"Primary approach: {request_text}",
+            novelty_level=0.3,
+            identity_effect="preserves",
+            move_id=moves[0].get("move_id", "") if moves else "",
+            created_at_ms=now,
+        ),
+        PreviewVariant(
+            variant_id=f"{set_id}_b",
+            label="option_b",
+            intent=f"Alternative approach: {request_text}",
+            novelty_level=0.6,
+            identity_effect="evolves",
+            move_id=moves[1].get("move_id", "") if len(moves) > 1 else "",
+            created_at_ms=now,
+        ),
+    ]
+
+
+# ── Comparison ────────────────────────────────────────────────────
+
+
+def compare_variants(
+    preview_set: PreviewSet,
+    criteria: Optional[dict] = None,
+) -> dict:
+    """Compare variants within a preview set and rank them."""
+    criteria = criteria or {}
+    weight_taste = criteria.get("taste_weight", 0.3)
+    weight_novelty = criteria.get("novelty_weight", 0.2)
+    weight_identity = criteria.get("identity_weight", 0.5)
+
+    rankings = []
+    for v in preview_set.variants:
+        # Score components
+        taste_score = v.taste_fit
+        novelty_score = 1.0 - abs(v.novelty_level - 0.5) * 2  # bell curve around 0.5
+        identity_score = _identity_effect_score(v.identity_effect)
+
+        composite = (
+            taste_score * weight_taste
+            + novelty_score * weight_novelty
+            + identity_score * weight_identity
+        )
+        v.score = round(composite, 3)
+
+        rankings.append({
+            "variant_id": v.variant_id,
+            "label": v.label,
+            "score": v.score,
+            "taste_fit": v.taste_fit,
+            "novelty_level": v.novelty_level,
+            "identity_effect": v.identity_effect,
+            "summary": v.intent,
+            "what_preserved": v.what_preserved,
+            "why_it_matters": v.why_it_matters,
+        })
+
+    rankings.sort(key=lambda r: r["score"], reverse=True)
+
+    comparison = {
+        "rankings": rankings,
+        "recommended": rankings[0]["variant_id"] if rankings else "",
+        "criteria_used": {
+            "taste_weight": weight_taste,
+            "novelty_weight": weight_novelty,
+            "identity_weight": weight_identity,
+        },
+    }
+
+    preview_set.comparison = comparison
+    preview_set.status = "compared"
+    return comparison
+
+
+def commit_variant(preview_set: PreviewSet, variant_id: str) -> Optional[PreviewVariant]:
+    """Mark a variant as committed and discard others."""
+    chosen = None
+    for v in preview_set.variants:
+        if v.variant_id == variant_id:
+            v.status = "committed"
+            chosen = v
+        else:
+            v.status = "discarded"
+
+    if chosen:
+        preview_set.committed_variant_id = variant_id
+        preview_set.status = "committed"
+
+    return chosen
+
+
+def discard_set(set_id: str) -> bool:
+    """Discard an entire preview set."""
+    ps = _preview_sets.pop(set_id, None)
+    if ps:
+        ps.status = "discarded"
+        for v in ps.variants:
+            v.status = "discarded"
+        return True
+    return False
+
+
+# ── Helpers ───────────────────────────────────────────────────────
+
+
+def _compute_set_id(request_text: str, kernel_id: str) -> str:
+    seed = json.dumps({"request": request_text, "kernel": kernel_id}, sort_keys=True)
+    return "ps_" + hashlib.sha256(seed.encode()).hexdigest()[:10]
+
+
+def _estimate_taste_fit(novelty: float, taste_graph: dict) -> float:
+    """Estimate how well a novelty level fits user taste."""
+    boldness = taste_graph.get("transition_boldness", 0.5)
+    # Users who like boldness prefer higher novelty
+    fit = 1.0 - abs(novelty - boldness) * 0.5
+    return round(max(0.0, min(1.0, fit)), 3)
+
+
+def _identity_effect_score(effect: str) -> float:
+    """Score identity effects — preserves is safest."""
+    return {
+        "preserves": 0.9,
+        "evolves": 0.7,
+        "contrasts": 0.4,
+        "resets": 0.2,
+    }.get(effect, 0.5)

package/mcp_server/preview_studio/models.py

@@ -0,0 +1,73 @@
+"""Preview Studio data models — pure dataclasses, zero I/O."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import asdict, dataclass, field
+from typing import Optional
+
+
+@dataclass
+class PreviewVariant:
+    """One creative option in a preview set."""
+
+    variant_id: str = ""
+    label: str = ""  # "safe", "strong", "unexpected"
+    intent: str = ""  # what this variant is trying to achieve
+    novelty_level: float = 0.0  # 0=conservative, 1=radical
+    songbrain_delta: str = ""  # what changed vs identity
+    taste_fit: float = 0.5  # 0-1 how well it matches user taste
+    render_ref: str = ""  # reference to cached render
+    summary: str = ""  # one-line musical explanation
+
+    # What changed, why it matters, what it preserves
+    what_changed: str = ""
+    why_it_matters: str = ""
+    what_preserved: str = ""
+
+    # Move / plan data
+    move_id: str = ""
+    compiled_plan: Optional[dict] = None
+
+    # Scoring
+    score: float = 0.0
+    identity_effect: str = "preserves"  # preserves, evolves, contrasts, resets
+
+    # State
+    status: str = "pending"  # pending, rendered, committed, discarded
+    created_at_ms: int = 0
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        # Remove None compiled_plan for cleaner output
+        if d.get("compiled_plan") is None:
+            d.pop("compiled_plan", None)
+        return d
+
+
+@dataclass
+class PreviewSet:
+    """A set of variants tied to one user request."""
+
+    set_id: str = ""
+    request_text: str = ""
+    strategy: str = "creative_triptych"  # creative_triptych, binary, custom
+    source_kernel_id: str = ""
+    variants: list[PreviewVariant] = field(default_factory=list)
+    comparison: Optional[dict] = None
+    committed_variant_id: str = ""
+    status: str = "pending"  # pending, compared, committed, discarded
+    created_at_ms: int = field(default_factory=lambda: int(time.time() * 1000))
+
+    def to_dict(self) -> dict:
+        return {
+            "set_id": self.set_id,
+            "request_text": self.request_text,
+            "strategy": self.strategy,
+            "source_kernel_id": self.source_kernel_id,
+            "variants": [v.to_dict() for v in self.variants],
+            "comparison": self.comparison,
+            "committed_variant_id": self.committed_variant_id,
+            "status": self.status,
+            "variant_count": len(self.variants),
+        }