livepilot 1.9.22 → 1.9.24

package/mcp_server/musical_intelligence/tools.py

@@ -0,0 +1,224 @@
+"""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,
+        })
+
+    # Motif data — via shared motif service
+    motif_graph = None
+    try:
+        from ..services.motif_service import get_motif_data, fetch_notes_from_ableton
+        session_info = ableton.send_command("get_session_info", {})
+        track_list = session_info.get("tracks", [])
+        notes_by_track = fetch_notes_from_ableton(ableton, track_list)
+        motif_graph = get_motif_data(notes_by_track)
+    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
+
+    # Direct Python calls to perception engine — not TCP
+    try:
+        from ..tools._perception_engine import compute_loudness
+        loudness_data = compute_loudness(file_path, detail="full")
+    except Exception:
+        pass
+
+    try:
+        from ..tools._perception_engine import compute_spectral
+        spectrum_data = compute_spectral(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/persistence/__init__.py

@@ -0,0 +1 @@
+"""Persistent storage for LivePilot state that survives server restart."""

package/mcp_server/persistence/base_store.py

@@ -0,0 +1,82 @@
+"""Persistent JSON store with atomic writes and corruption recovery.
+
+Follows the TechniqueStore pattern: lazy init, atomic tmp+rename,
+fsync to disk, corruption recovery via .corrupt rename.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+from pathlib import Path
+
+
+class PersistentJsonStore:
+    """Thread-safe, crash-safe JSON file store."""
+
+    def __init__(self, path: Path):
+        self._path = Path(path)
+        self._lock = threading.RLock()
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    def read(self) -> dict:
+        """Read the store. Returns {} if missing or corrupt."""
+        with self._lock:
+            if not self._path.exists():
+                return {}
+            try:
+                return json.loads(self._path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                corrupt = self._path.with_suffix(self._path.suffix + ".corrupt")
+                try:
+                    self._path.rename(corrupt)
+                except OSError:
+                    pass
+                return {}
+
+    def write(self, data: dict) -> None:
+        """Atomically write data to disk."""
+        with self._lock:
+            self._path.parent.mkdir(parents=True, exist_ok=True)
+            tmp = self._path.with_suffix(".tmp")
+            try:
+                with open(tmp, "w", encoding="utf-8") as f:
+                    json.dump(data, f, indent=2, default=str)
+                    f.flush()
+                    os.fsync(f.fileno())
+                os.replace(str(tmp), str(self._path))
+            except OSError:
+                try:
+                    tmp.unlink(missing_ok=True)
+                except OSError:
+                    pass
+                raise
+
+    def update(self, updater) -> dict:
+        """Read-modify-write atomically. updater(data) -> modified data."""
+        with self._lock:
+            data = self._read_unlocked()
+            data = updater(data)
+            self._write_unlocked(data)
+            return data
+
+    def _read_unlocked(self) -> dict:
+        if not self._path.exists():
+            return {}
+        try:
+            return json.loads(self._path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def _write_unlocked(self, data: dict) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self._path.with_suffix(".tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, default=str)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(str(tmp), str(self._path))

package/mcp_server/persistence/project_store.py

@@ -0,0 +1,106 @@
+"""Per-project persistent state — threads, turns, Wonder outcomes.
+
+Stores session continuity data scoped to a project identity.
+Located at ~/.livepilot/projects/<hash>/state.json.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import time
+from pathlib import Path
+from typing import Optional
+
+from .base_store import PersistentJsonStore
+
+
+_PROJECTS_DIR = Path.home() / ".livepilot" / "projects"
+_MAX_TURNS = 50
+_MAX_WONDER_OUTCOMES = 10
+
+
+def project_hash(session_info: dict) -> str:
+    """Compute a stable project fingerprint from session info.
+
+    Uses tempo + track count + sorted track names. This is imperfect
+    but stable enough for per-song state within a production session.
+    """
+    tempo = session_info.get("tempo", 120.0)
+    tracks = session_info.get("tracks", [])
+    track_names = sorted(t.get("name", "") for t in tracks if isinstance(t, dict))
+    seed = f"{tempo:.1f}|{len(tracks)}|{'|'.join(track_names)}"
+    return hashlib.sha256(seed.encode()).hexdigest()[:12]
+
+
+class ProjectStore:
+    """Persistent per-project state."""
+
+    def __init__(self, project_id: str, base_dir: Optional[Path] = None):
+        base = base_dir or _PROJECTS_DIR
+        self._store = PersistentJsonStore(base / project_id / "state.json")
+        self._project_id = project_id
+
+    @property
+    def project_id(self) -> str:
+        return self._project_id
+
+    def get_all(self) -> dict:
+        data = self._store.read()
+        return data if data.get("version") == 1 else self._default()
+
+    def save_thread(self, thread: dict) -> None:
+        """Save or update a creative thread."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            threads = data.setdefault("threads", [])
+            # Update existing or append
+            for i, t in enumerate(threads):
+                if t.get("thread_id") == thread.get("thread_id"):
+                    threads[i] = thread
+                    return data
+            threads.append(thread)
+            return data
+        self._store.update(_update)
+
+    def save_turn(self, turn: dict) -> None:
+        """Save a turn resolution (capped at MAX_TURNS)."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            turns = data.setdefault("turns", [])
+            turns.append(turn)
+            # Cap at max
+            if len(turns) > _MAX_TURNS:
+                data["turns"] = turns[-_MAX_TURNS:]
+            data["last_updated_ms"] = int(time.time() * 1000)
+            return data
+        self._store.update(_update)
+
+    def save_wonder_outcome(self, outcome: dict) -> None:
+        """Save a Wonder session outcome (capped at MAX_WONDER_OUTCOMES)."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            outcomes = data.setdefault("wonder_outcomes", [])
+            outcomes.append(outcome)
+            if len(outcomes) > _MAX_WONDER_OUTCOMES:
+                data["wonder_outcomes"] = outcomes[-_MAX_WONDER_OUTCOMES:]
+            return data
+        self._store.update(_update)
+
+    def get_threads(self) -> list[dict]:
+        return self.get_all().get("threads", [])
+
+    def get_turns(self) -> list[dict]:
+        return self.get_all().get("turns", [])
+
+    def get_wonder_outcomes(self) -> list[dict]:
+        return self.get_all().get("wonder_outcomes", [])
+
+    @staticmethod
+    def _default() -> dict:
+        return {
+            "version": 1,
+            "threads": [],
+            "turns": [],
+            "wonder_outcomes": [],
+            "last_updated_ms": 0,
+        }

package/mcp_server/persistence/taste_store.py

@@ -0,0 +1,122 @@
+"""Persistent taste state — survives server restart.
+
+Stores move outcomes, novelty preference, device affinity,
+anti-preferences, and dimension weights. Located at
+~/.livepilot/taste.json.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Optional
+
+from .base_store import PersistentJsonStore
+
+
+_DEFAULT_PATH = Path.home() / ".livepilot" / "taste.json"
+
+
+class PersistentTasteStore:
+    """Persistent backing for TasteGraph data."""
+
+    def __init__(self, path: Optional[Path] = None):
+        self._store = PersistentJsonStore(path or _DEFAULT_PATH)
+
+    def get_all(self) -> dict:
+        """Get all persisted taste data."""
+        data = self._store.read()
+        return data if data.get("version") == 1 else self._default()
+
+    def record_move_outcome(
+        self, move_id: str, family: str, kept: bool, score: float = 0.0,
+    ) -> None:
+        """Persist a move outcome."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            outcomes = data.setdefault("move_outcomes", {})
+            entry = outcomes.setdefault(move_id, {
+                "family": family, "kept_count": 0, "undone_count": 0,
+            })
+            entry["family"] = family
+            if kept:
+                entry["kept_count"] = entry.get("kept_count", 0) + 1
+            else:
+                entry["undone_count"] = entry.get("undone_count", 0) + 1
+            data["evidence_count"] = data.get("evidence_count", 0) + 1
+            data["last_updated_ms"] = int(time.time() * 1000)
+            return data
+        self._store.update(_update)
+
+    def update_novelty(self, chose_bold: bool) -> None:
+        """Update novelty band from experiment choice."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            band = data.get("novelty_band", 0.5)
+            if chose_bold:
+                data["novelty_band"] = min(1.0, band + 0.05)
+            else:
+                data["novelty_band"] = max(0.0, band - 0.05)
+            data["evidence_count"] = data.get("evidence_count", 0) + 1
+            return data
+        self._store.update(_update)
+
+    def record_device_use(self, device_name: str, positive: bool = True) -> None:
+        """Persist device affinity."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            affinities = data.setdefault("device_affinities", {})
+            entry = affinities.setdefault(device_name, {
+                "affinity": 0.0, "use_count": 0,
+            })
+            entry["use_count"] = entry.get("use_count", 0) + 1
+            aff = entry.get("affinity", 0.0)
+            if positive:
+                entry["affinity"] = min(1.0, aff + 0.05)
+            else:
+                entry["affinity"] = max(-1.0, aff - 0.08)
+            data["evidence_count"] = data.get("evidence_count", 0) + 1
+            return data
+        self._store.update(_update)
+
+    def record_anti_preference(self, dimension: str, direction: str) -> None:
+        """Persist an anti-preference."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            antis = data.setdefault("anti_preferences", [])
+            existing = next(
+                (a for a in antis if a["dimension"] == dimension and a["direction"] == direction),
+                None,
+            )
+            if existing:
+                existing["count"] = existing.get("count", 0) + 1
+                existing["strength"] = min(1.0, existing["count"] * 0.2)
+            else:
+                antis.append({
+                    "dimension": dimension, "direction": direction,
+                    "count": 1, "strength": 0.2,
+                })
+            data["evidence_count"] = data.get("evidence_count", 0) + 1
+            return data
+        self._store.update(_update)
+
+    def record_dimension_weight(self, dimension: str, value: float) -> None:
+        """Persist a dimension weight update."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            data.setdefault("dimension_weights", {})[dimension] = round(value, 3)
+            return data
+        self._store.update(_update)
+
+    @staticmethod
+    def _default() -> dict:
+        return {
+            "version": 1,
+            "move_outcomes": {},
+            "novelty_band": 0.5,
+            "device_affinities": {},
+            "anti_preferences": [],
+            "dimension_weights": {},
+            "evidence_count": 0,
+            "last_updated_ms": 0,
+        }

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.
+"""