livepilot 1.9.21 → 1.9.23

package/mcp_server/experiment/models.py

@@ -0,0 +1,120 @@
+"""Experiment branch data models.
+
+An ExperimentBranch represents one trial of a semantic move against the
+current session state. Multiple branches form an experiment set that can
+be compared and ranked.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+
+@dataclass
+class BranchSnapshot:
+    """Captured state before or after a branch experiment."""
+    spectrum: Optional[dict] = None
+    rms: Optional[float] = None
+    peak: Optional[float] = None
+    track_meters: Optional[list] = None
+    timestamp_ms: int = 0
+
+    def to_dict(self) -> dict:
+        d = {}
+        if self.spectrum is not None:
+            d["spectrum"] = self.spectrum
+        if self.rms is not None:
+            d["rms"] = self.rms
+        if self.peak is not None:
+            d["peak"] = self.peak
+        if self.track_meters is not None:
+            d["track_meters"] = self.track_meters
+        d["timestamp_ms"] = self.timestamp_ms
+        return d
+
+
+@dataclass
+class ExperimentBranch:
+    """One trial branch in an experiment set."""
+    branch_id: str
+    name: str
+    move_id: str
+    source_kernel_id: str = ""
+    status: str = "pending"  # pending | running | evaluated | committed | discarded
+
+    # Compiled plan for this branch
+    compiled_plan: Optional[dict] = None
+
+    # Captured snapshots
+    before_snapshot: Optional[BranchSnapshot] = None
+    after_snapshot: Optional[BranchSnapshot] = None
+
+    # Evaluation results
+    evaluation: Optional[dict] = None
+    score: float = 0.0
+
+    # Metadata
+    created_at_ms: int = 0
+    executed_at_ms: int = 0
+
+    def to_dict(self) -> dict:
+        d = {
+            "branch_id": self.branch_id,
+            "name": self.name,
+            "move_id": self.move_id,
+            "status": self.status,
+            "score": self.score,
+            "created_at_ms": self.created_at_ms,
+        }
+        if self.compiled_plan:
+            d["step_count"] = self.compiled_plan.get("step_count", 0)
+            d["summary"] = self.compiled_plan.get("summary", "")
+        if self.before_snapshot:
+            d["before_snapshot"] = self.before_snapshot.to_dict()
+        if self.after_snapshot:
+            d["after_snapshot"] = self.after_snapshot.to_dict()
+        if self.evaluation:
+            d["evaluation"] = self.evaluation
+        return d
+
+
+@dataclass
+class ExperimentSet:
+    """A collection of branches being compared for one request."""
+    experiment_id: str
+    request_text: str
+    branches: list[ExperimentBranch] = field(default_factory=list)
+    status: str = "open"  # open | evaluated | committed | discarded
+    winner_branch_id: Optional[str] = None
+    created_at_ms: int = 0
+
+    @property
+    def branch_count(self) -> int:
+        return len(self.branches)
+
+    def get_branch(self, branch_id: str) -> Optional[ExperimentBranch]:
+        for b in self.branches:
+            if b.branch_id == branch_id:
+                return b
+        return None
+
+    def ranked_branches(self) -> list[ExperimentBranch]:
+        """Return branches sorted by score descending."""
+        evaluated = [b for b in self.branches if b.status == "evaluated"]
+        return sorted(evaluated, key=lambda b: -b.score)
+
+    def to_dict(self) -> dict:
+        return {
+            "experiment_id": self.experiment_id,
+            "request_text": self.request_text,
+            "status": self.status,
+            "branch_count": self.branch_count,
+            "branches": [b.to_dict() for b in self.branches],
+            "winner_branch_id": self.winner_branch_id,
+            "ranking": [
+                {"branch_id": b.branch_id, "name": b.name, "score": b.score}
+                for b in self.ranked_branches()
+            ],
+        }

package/mcp_server/experiment/tools.py

@@ -0,0 +1,263 @@
+"""Experiment MCP tools — create, run, compare, commit, discard experiments.
+
+5 tools for branch-based creative search:
+  create_experiment — set up branches from semantic moves
+  run_experiment — trial each branch (apply → capture → undo)
+  compare_experiments — rank branches by evaluation score
+  commit_experiment — re-apply the winner permanently
+  discard_experiment — throw away all branches
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Optional
+
+from fastmcp import Context
+
+from ..server import mcp
+from . import engine
+from .models import BranchSnapshot
+
+
+def _get_ableton(ctx: Context):
+    return ctx.lifespan_context["ableton"]
+
+
+def _capture_snapshot(ctx: Context) -> BranchSnapshot:
+    """Capture current session state as a BranchSnapshot."""
+    ableton = _get_ableton(ctx)
+    spectral = ctx.lifespan_context.get("spectral")
+
+    snapshot = BranchSnapshot(timestamp_ms=int(time.time() * 1000))
+
+    # Track meters (always available)
+    try:
+        meters = ableton.send_command("get_track_meters", {"include_stereo": True})
+        snapshot.track_meters = meters.get("tracks", [])
+    except Exception:
+        pass
+
+    # Spectral data (requires M4L analyzer)
+    if spectral and spectral.is_connected:
+        try:
+            spec = spectral.get("spectrum")
+            if spec:
+                snapshot.spectrum = spec.get("value", {})
+        except Exception:
+            pass
+
+        try:
+            rms_data = spectral.get("rms")
+            if rms_data:
+                snapshot.rms = rms_data.get("value")
+        except Exception:
+            pass
+
+    return snapshot
+
+
+@mcp.tool()
+def create_experiment(
+    ctx: Context,
+    request_text: str,
+    move_ids: Optional[list] = None,
+    limit: int = 3,
+) -> dict:
+    """Create an experiment set to compare multiple approaches.
+
+    If move_ids is provided, creates one branch per move.
+    Otherwise, uses propose_next_best_move to find candidates.
+
+    request_text: what the user wants (e.g., "make this punchier")
+    move_ids: specific moves to try (e.g., ["make_punchier", "tighten_low_end"])
+    limit: max branches when auto-proposing (default 3)
+
+    Returns: experiment set with branch IDs ready for run_experiment.
+    """
+    if not move_ids:
+        # Auto-propose moves from the registry
+        from ..semantic_moves import registry
+        from ..semantic_moves.tools import propose_next_best_move
+        # Use the propose function's logic directly
+        all_moves = list(registry._REGISTRY.values())
+        request_lower = request_text.lower()
+        scored = []
+        for move in all_moves:
+            score = 0.0
+            move_words = set(move.move_id.replace("_", " ").split())
+            intent_words = set(move.intent.lower().split())
+            request_words = set(request_lower.split())
+            overlap = request_words & (move_words | intent_words)
+            score += len(overlap) * 0.3
+            for dim in move.targets:
+                if dim in request_lower:
+                    score += 0.2
+            if score > 0.1:
+                scored.append((move.move_id, score))
+        scored.sort(key=lambda x: -x[1])
+        move_ids = [m[0] for m, _ in scored[:limit]] if scored else []
+
+    if not move_ids:
+        return {"error": "No matching semantic moves found for this request"}
+
+    # Build kernel_id from session
+    ableton = _get_ableton(ctx)
+    session = ableton.send_command("get_session_info")
+    kernel_id = f"kern_{int(time.time())}"
+
+    experiment = engine.create_experiment(
+        request_text=request_text,
+        move_ids=move_ids,
+        kernel_id=kernel_id,
+    )
+
+    return experiment.to_dict()
+
+
+@mcp.tool()
+def run_experiment(
+    ctx: Context,
+    experiment_id: str,
+) -> dict:
+    """Run all pending branches in an experiment.
+
+    For each branch:
+    1. Compile the semantic move against current session
+    2. Capture before state
+    3. Execute the compiled plan
+    4. Capture after state
+    5. Undo all changes (revert to checkpoint)
+    6. Evaluate the branch
+
+    Branches run sequentially (Ableton has linear undo).
+    """
+    experiment = engine.get_experiment(experiment_id)
+    if not experiment:
+        return {"error": f"Experiment {experiment_id} not found"}
+
+    ableton = _get_ableton(ctx)
+
+    # Import compiler
+    from ..semantic_moves import registry, compiler
+
+    results = []
+    for branch in experiment.branches:
+        if branch.status != "pending":
+            continue
+
+        # Compile the move
+        move = registry.get_move(branch.move_id)
+        if not move:
+            branch.status = "evaluated"
+            branch.score = 0.0
+            branch.evaluation = {"error": f"Move {branch.move_id} not found"}
+            results.append(branch.to_dict())
+            continue
+
+        session_info = ableton.send_command("get_session_info")
+        kernel = {"session_info": session_info, "mode": "explore"}
+        plan = compiler.compile(move, kernel)
+        compiled_dict = plan.to_dict()
+
+        # Run the branch (apply → capture → undo)
+        engine.run_branch(
+            branch=branch,
+            ableton=ableton,
+            compiled_plan=compiled_dict,
+            capture_fn=lambda: _capture_snapshot(ctx),
+        )
+
+        # Evaluate
+        def eval_fn(before, after):
+            # Simple heuristic evaluation when spectral data isn't available
+            score = 0.5  # Neutral
+            if before.get("track_meters") and after.get("track_meters"):
+                # Check all tracks still alive
+                before_alive = sum(1 for t in before["track_meters"] if t.get("level", 0) > 0)
+                after_alive = sum(1 for t in after["track_meters"] if t.get("level", 0) > 0)
+                if after_alive >= before_alive:
+                    score += 0.1
+                else:
+                    score -= 0.2  # Lost a track
+
+            if before.get("spectrum") and after.get("spectrum"):
+                # Spectral balance improvement heuristic
+                score += 0.1  # Bonus for having spectral data
+
+            return {"score": round(score, 3), "keep_change": score > 0.45}
+
+        engine.evaluate_branch(branch, eval_fn)
+        results.append(branch.to_dict())
+
+    return {
+        "experiment_id": experiment_id,
+        "branches_run": len(results),
+        "results": results,
+        "ranking": [
+            {"branch_id": b.branch_id, "name": b.name, "score": b.score, "move_id": b.move_id}
+            for b in experiment.ranked_branches()
+        ],
+    }
+
+
+@mcp.tool()
+def compare_experiments(
+    ctx: Context,
+    experiment_id: str,
+) -> dict:
+    """Compare and rank all evaluated branches in an experiment.
+
+    Returns branches sorted by score with their evaluations and summaries.
+    """
+    experiment = engine.get_experiment(experiment_id)
+    if not experiment:
+        return {"error": f"Experiment {experiment_id} not found"}
+
+    ranked = experiment.ranked_branches()
+    return {
+        "experiment_id": experiment_id,
+        "request": experiment.request_text,
+        "branch_count": experiment.branch_count,
+        "ranking": [
+            {
+                "rank": i + 1,
+                "branch_id": b.branch_id,
+                "name": b.name,
+                "move_id": b.move_id,
+                "score": b.score,
+                "summary": b.compiled_plan.get("summary", "") if b.compiled_plan else "",
+                "evaluation": b.evaluation,
+            }
+            for i, b in enumerate(ranked)
+        ],
+        "winner": ranked[0].to_dict() if ranked else None,
+    }
+
+
+@mcp.tool()
+def commit_experiment(
+    ctx: Context,
+    experiment_id: str,
+    branch_id: str,
+) -> dict:
+    """Commit the winning branch — re-apply its moves permanently.
+
+    This executes the branch's compiled plan again, this time without undoing.
+    The experiment is marked as committed.
+    """
+    experiment = engine.get_experiment(experiment_id)
+    if not experiment:
+        return {"error": f"Experiment {experiment_id} not found"}
+
+    ableton = _get_ableton(ctx)
+    return engine.commit_branch(experiment, branch_id, ableton)
+
+
+@mcp.tool()
+def discard_experiment(
+    ctx: Context,
+    experiment_id: str,
+) -> dict:
+    """Discard an entire experiment — no changes are kept."""
+    return engine.discard_experiment(experiment_id)

package/mcp_server/hook_hunter/__init__.py

@@ -0,0 +1,5 @@
+"""Hook Hunter — melodic/rhythmic/timbral salience analysis for Stage 2.
+
+Identifies what the track is most "about," ranks hook candidates,
+and provides phrase-level payoff scoring.
+"""