livepilot 1.9.13 → 1.9.15

package/mcp_server/project_brain/automation_graph.py

@@ -0,0 +1,72 @@
+"""Automation graph builder — scans track devices for automation presence.
+
+Pure computation, zero I/O.
+"""
+
+from __future__ import annotations
+
+from .models import AutomationGraph
+
+
+def build_automation_graph(
+    track_infos: list[dict],
+    sections: list[dict] | None = None,
+) -> AutomationGraph:
+    """Build an AutomationGraph by scanning track device info for automation.
+
+    Args:
+        track_infos: list of per-track info dicts.  Each may contain:
+            - index: track index
+            - name: track name
+            - devices: [{name, class_name, parameters: [{name, value, is_automated, ...}]}]
+        sections: optional list of section dicts (for density_by_section).
+
+    Returns:
+        AutomationGraph with automated_params and density_by_section.
+    """
+    graph = AutomationGraph()
+
+    if not track_infos:
+        return graph
+
+    automated_params = []
+
+    for track in track_infos:
+        t_idx = track.get("index", 0)
+        t_name = track.get("name", "")
+        devices = track.get("devices", [])
+
+        for device in devices:
+            device_name = device.get("name", device.get("class_name", ""))
+            parameters = device.get("parameters", [])
+
+            for param in parameters:
+                if param.get("is_automated", False) or param.get("automation_state", 0) > 0:
+                    automated_params.append({
+                        "track_index": t_idx,
+                        "track_name": t_name,
+                        "device_name": device_name,
+                        "param_name": param.get("name", ""),
+                        "param_value": param.get("value"),
+                    })
+
+    graph.automated_params = automated_params
+
+    # Compute density_by_section if sections are provided
+    if sections:
+        total_automated = len(automated_params)
+        for sec in sections:
+            section_id = sec.get("section_id", "")
+            # Without per-section automation data, distribute evenly
+            # and weight by section density (more active tracks = more automation)
+            sec_density = sec.get("density", 0.0)
+            # Automation density approximation: section density * param count ratio
+            if total_automated > 0:
+                graph.density_by_section[section_id] = round(
+                    sec_density * min(total_automated / max(len(track_infos), 1), 1.0),
+                    3,
+                )
+            else:
+                graph.density_by_section[section_id] = 0.0
+
+    return graph

package/mcp_server/project_brain/builder.py

@@ -0,0 +1,123 @@
+"""Project Brain build pipeline — orchestrates full state construction.
+
+Pure computation, zero I/O.  MCP tool wrappers call this with
+pre-fetched data from Ableton.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .arrangement_graph import build_arrangement_graph
+from .automation_graph import build_automation_graph
+from .capability_graph import build_capability_graph
+from .models import ProjectState
+from .role_graph import build_role_graph
+from .session_graph import build_session_graph
+
+
+def build_project_state_from_data(
+    session_info: dict,
+    scenes: Optional[list[dict]] = None,
+    clip_matrix: Optional[list[list[dict]]] = None,
+    track_infos: Optional[list[dict]] = None,
+    notes_map: Optional[dict[str, dict[int, list[dict]]]] = None,
+    arrangement_clips: Optional[dict] = None,
+    analyzer_ok: bool = False,
+    flucoma_ok: bool = False,
+    plugin_health: Optional[dict[str, Any]] = None,
+    session_ok: bool = True,
+    memory_ok: bool = False,
+    web_ok: bool = False,
+    analyzer_fresh: bool = False,
+    previous_revision: int = 0,
+) -> ProjectState:
+    """Build a full ProjectState from pre-fetched data.
+
+    Args:
+        session_info: raw get_session_info output.
+        scenes: list of scene dicts for arrangement graph.
+        clip_matrix: [scene_index][track_index] clip slot dicts.
+        track_infos: list of per-track info dicts (devices, params).
+        notes_map: {section_id: {track_index: [notes]}} for role inference.
+        arrangement_clips: legacy dict of track_index -> clip list.
+        analyzer_ok: whether M4L analyzer bridge is responding.
+        flucoma_ok: whether FluCoMa is available.
+        plugin_health: dict of plugin_name -> health info.
+        session_ok: whether Ableton session is reachable.
+        memory_ok: whether technique memory is available.
+        web_ok: whether web research is available.
+        analyzer_fresh: whether analyzer data is fresh.
+        previous_revision: last known revision number.
+
+    Returns:
+        ProjectState with incremented revision and all subgraphs populated.
+    """
+    state = ProjectState()
+    state.revision = previous_revision + 1
+
+    # 1. Session graph (always built)
+    state.session_graph = build_session_graph(session_info)
+    state.session_graph.freshness.mark_fresh(state.revision)
+
+    # 2. Arrangement graph
+    track_count = len(session_info.get("tracks", []))
+
+    if scenes and clip_matrix:
+        # New path: real scene-based section inference
+        state.arrangement_graph = build_arrangement_graph(
+            scenes, clip_matrix, track_count,
+        )
+    elif arrangement_clips:
+        # Legacy path: arrangement clips from per-track fetch
+        from .models import ArrangementGraph, SectionNode
+        arr = ArrangementGraph()
+        sections = []
+        for track_idx, clips in arrangement_clips.items():
+            for clip in clips:
+                sections.append(SectionNode(
+                    section_id=f"t{track_idx}_c{clip.get('index', 0)}",
+                    start_bar=int(clip.get("start_time", 0)),
+                    end_bar=int(clip.get("end_time", 0)),
+                    section_type=clip.get("name", "unknown"),
+                ))
+        arr.sections = sections
+        state.arrangement_graph = arr
+    # else: leave as default empty ArrangementGraph
+
+    state.arrangement_graph.freshness.mark_fresh(state.revision)
+
+    # 3. Role graph
+    if state.arrangement_graph.sections and track_infos:
+        section_dicts = [s.to_dict() for s in state.arrangement_graph.sections]
+        state.role_graph = build_role_graph(
+            sections=section_dicts,
+            track_data=track_infos,
+            notes_map=notes_map or {},
+        )
+    state.role_graph.freshness.mark_fresh(state.revision)
+
+    # 4. Automation graph
+    section_dicts_for_auto = (
+        [s.to_dict() for s in state.arrangement_graph.sections]
+        if state.arrangement_graph.sections else None
+    )
+    state.automation_graph = build_automation_graph(
+        track_infos=track_infos or [],
+        sections=section_dicts_for_auto,
+    )
+    state.automation_graph.freshness.mark_fresh(state.revision)
+
+    # 5. Capability graph
+    state.capability_graph = build_capability_graph(
+        analyzer_ok=analyzer_ok,
+        flucoma_ok=flucoma_ok,
+        plugin_health=plugin_health,
+        session_ok=session_ok,
+        memory_ok=memory_ok,
+        web_ok=web_ok,
+        analyzer_fresh=analyzer_fresh,
+    )
+    state.capability_graph.freshness.mark_fresh(state.revision)
+
+    return state

package/mcp_server/project_brain/capability_graph.py

@@ -0,0 +1,64 @@
+"""Capability graph builder — maps runtime checks to CapabilityGraph fields.
+
+Reuses runtime/capability_state.build_capability_state for the domain logic,
+then maps results to the brain CapabilityGraph model.
+
+Pure computation, zero I/O.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..runtime.capability_state import build_capability_state
+from .models import CapabilityGraph
+
+
+def build_capability_graph(
+    analyzer_ok: bool = False,
+    flucoma_ok: bool = False,
+    plugin_health: dict[str, Any] | None = None,
+    session_ok: bool = True,
+    memory_ok: bool = False,
+    web_ok: bool = False,
+    analyzer_fresh: bool = False,
+) -> CapabilityGraph:
+    """Build a CapabilityGraph from runtime probe results.
+
+    Args:
+        analyzer_ok: whether the M4L analyzer bridge is responding.
+        flucoma_ok: whether FluCoMa is available.
+        plugin_health: dict of plugin_name -> health info (parameter_count, etc.).
+        session_ok: whether Ableton session is reachable.
+        memory_ok: whether technique memory is available.
+        web_ok: whether web research is available.
+        analyzer_fresh: whether analyzer data is fresh (< 5s old).
+
+    Returns:
+        CapabilityGraph with all fields populated (freshness unfreshed).
+    """
+    # Delegate to capability_state for domain reasoning
+    cap_state = build_capability_state(
+        session_ok=session_ok,
+        analyzer_ok=analyzer_ok,
+        analyzer_fresh=analyzer_fresh,
+        memory_ok=memory_ok,
+        web_ok=web_ok,
+        flucoma_ok=flucoma_ok,
+    )
+
+    # Map to brain model
+    graph = CapabilityGraph(
+        analyzer_available=analyzer_ok and analyzer_fresh,
+        flucoma_available=flucoma_ok,
+        plugin_health=plugin_health or {},
+    )
+
+    # Populate research providers from capability state domains
+    research_providers = []
+    for domain_name, domain in cap_state.domains.items():
+        if domain.available and domain_name in ("session_access", "memory", "web"):
+            research_providers.append(domain_name)
+    graph.research_providers = sorted(research_providers)
+
+    return graph

package/mcp_server/project_brain/models.py

@@ -0,0 +1,282 @@
+"""Project Brain data models — all dataclasses with to_dict().
+
+Zero I/O.  Pure data structures representing the five subgraphs
+(SessionGraph, ArrangementGraph, RoleGraph, AutomationGraph,
+CapabilityGraph) plus freshness/confidence metadata.
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+
+# ── Freshness ────────────────────────────────────────────────────────
+
+
+@dataclass
+class FreshnessInfo:
+    """Tracks when a subgraph was built and whether it is stale."""
+
+    built_at_ms: float = 0.0
+    source_revision: int = 0
+    stale: bool = True
+    stale_reason: Optional[str] = "never built"
+
+    def mark_fresh(self, revision: int) -> None:
+        self.built_at_ms = time.time() * 1000
+        self.source_revision = revision
+        self.stale = False
+        self.stale_reason = None
+
+    def mark_stale(self, reason: str) -> None:
+        self.stale = True
+        self.stale_reason = reason
+
+    def to_dict(self) -> dict:
+        return {
+            "built_at_ms": self.built_at_ms,
+            "source_revision": self.source_revision,
+            "stale": self.stale,
+            "stale_reason": self.stale_reason,
+        }
+
+
+# ── Confidence ───────────────────────────────────────────────────────
+
+
+@dataclass
+class ConfidenceInfo:
+    """Confidence summary for inference-bearing graphs."""
+
+    overall: float = 0.0
+    low_confidence_nodes: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "overall": self.overall,
+            "low_confidence_nodes": list(self.low_confidence_nodes),
+        }
+
+
+# ── SessionGraph ─────────────────────────────────────────────────────
+
+
+@dataclass
+class TrackNode:
+    """A single track in the session."""
+
+    index: int = 0
+    name: str = ""
+    has_midi: bool = False
+    has_audio: bool = False
+    mute: bool = False
+    solo: bool = False
+    arm: bool = False
+    group_index: Optional[int] = None
+
+    def to_dict(self) -> dict:
+        return {
+            "index": self.index,
+            "name": self.name,
+            "has_midi": self.has_midi,
+            "has_audio": self.has_audio,
+            "mute": self.mute,
+            "solo": self.solo,
+            "arm": self.arm,
+            "group_index": self.group_index,
+        }
+
+
+@dataclass
+class SessionGraph:
+    """Physical/session topology — tracks, returns, scenes, tempo."""
+
+    tracks: list[TrackNode] = field(default_factory=list)
+    return_tracks: list[dict] = field(default_factory=list)
+    scenes: list[dict] = field(default_factory=list)
+    tempo: float = 120.0
+    time_signature: str = "4/4"
+    freshness: FreshnessInfo = field(default_factory=FreshnessInfo)
+
+    def add_track(self, track: TrackNode) -> None:
+        self.tracks.append(track)
+
+    def to_dict(self) -> dict:
+        return {
+            "tracks": [t.to_dict() for t in self.tracks],
+            "return_tracks": list(self.return_tracks),
+            "scenes": list(self.scenes),
+            "tempo": self.tempo,
+            "time_signature": self.time_signature,
+            "freshness": self.freshness.to_dict(),
+        }
+
+
+# ── ArrangementGraph ─────────────────────────────────────────────────
+
+
+@dataclass
+class SectionNode:
+    """A section in the arrangement timeline."""
+
+    section_id: str = ""
+    start_bar: int = 0
+    end_bar: int = 0
+    section_type: str = "unknown"
+    energy: float = 0.0
+    density: float = 0.0
+
+    def to_dict(self) -> dict:
+        return {
+            "section_id": self.section_id,
+            "start_bar": self.start_bar,
+            "end_bar": self.end_bar,
+            "section_type": self.section_type,
+            "energy": self.energy,
+            "density": self.density,
+        }
+
+
+@dataclass
+class ArrangementGraph:
+    """Time-structure layer — sections, boundaries, cue points."""
+
+    sections: list[SectionNode] = field(default_factory=list)
+    boundaries: list[dict] = field(default_factory=list)
+    cue_points: list[dict] = field(default_factory=list)
+    freshness: FreshnessInfo = field(default_factory=FreshnessInfo)
+
+    def to_dict(self) -> dict:
+        return {
+            "sections": [s.to_dict() for s in self.sections],
+            "boundaries": list(self.boundaries),
+            "cue_points": list(self.cue_points),
+            "freshness": self.freshness.to_dict(),
+        }
+
+
+# ── RoleGraph ────────────────────────────────────────────────────────
+
+
+@dataclass
+class RoleNode:
+    """Maps a musical function to a track within a section."""
+
+    track_index: int = 0
+    section_id: str = ""
+    role: str = "unknown"
+    confidence: float = 0.0
+    foreground: bool = False
+
+    def to_dict(self) -> dict:
+        return {
+            "track_index": self.track_index,
+            "section_id": self.section_id,
+            "role": self.role,
+            "confidence": self.confidence,
+            "foreground": self.foreground,
+        }
+
+
+@dataclass
+class RoleGraph:
+    """Musical function assignments across tracks and sections."""
+
+    roles: list[RoleNode] = field(default_factory=list)
+    confidence: ConfidenceInfo = field(default_factory=ConfidenceInfo)
+    freshness: FreshnessInfo = field(default_factory=FreshnessInfo)
+
+    def add_role(self, role: RoleNode) -> None:
+        self.roles.append(role)
+
+    def to_dict(self) -> dict:
+        return {
+            "roles": [r.to_dict() for r in self.roles],
+            "confidence": self.confidence.to_dict(),
+            "freshness": self.freshness.to_dict(),
+        }
+
+
+# ── AutomationGraph ──────────────────────────────────────────────────
+
+
+@dataclass
+class AutomationGraph:
+    """Automation presence and gesture density."""
+
+    automated_params: list[dict] = field(default_factory=list)
+    density_by_section: dict[str, float] = field(default_factory=dict)
+    freshness: FreshnessInfo = field(default_factory=FreshnessInfo)
+
+    def to_dict(self) -> dict:
+        return {
+            "automated_params": list(self.automated_params),
+            "density_by_section": dict(self.density_by_section),
+            "freshness": self.freshness.to_dict(),
+        }
+
+
+# ── CapabilityGraph ──────────────────────────────────────────────────
+
+
+@dataclass
+class CapabilityGraph:
+    """Runtime capability awareness — what tools/features are available."""
+
+    analyzer_available: bool = False
+    flucoma_available: bool = False
+    plugin_health: dict[str, Any] = field(default_factory=dict)
+    research_providers: list[str] = field(default_factory=list)
+    freshness: FreshnessInfo = field(default_factory=FreshnessInfo)
+
+    def to_dict(self) -> dict:
+        return {
+            "analyzer_available": self.analyzer_available,
+            "flucoma_available": self.flucoma_available,
+            "plugin_health": dict(self.plugin_health),
+            "research_providers": list(self.research_providers),
+            "freshness": self.freshness.to_dict(),
+        }
+
+
+# ── ProjectState ─────────────────────────────────────────────────────
+
+
+@dataclass
+class ProjectState:
+    """Top-level container — one canonical project snapshot."""
+
+    project_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
+    revision: int = 0
+    session_graph: SessionGraph = field(default_factory=SessionGraph)
+    arrangement_graph: ArrangementGraph = field(default_factory=ArrangementGraph)
+    role_graph: RoleGraph = field(default_factory=RoleGraph)
+    automation_graph: AutomationGraph = field(default_factory=AutomationGraph)
+    capability_graph: CapabilityGraph = field(default_factory=CapabilityGraph)
+    active_issues: list[dict] = field(default_factory=list)
+
+    def is_stale(self) -> bool:
+        """True if any subgraph is stale."""
+        return any([
+            self.session_graph.freshness.stale,
+            self.arrangement_graph.freshness.stale,
+            self.role_graph.freshness.stale,
+            self.automation_graph.freshness.stale,
+            self.capability_graph.freshness.stale,
+        ])
+
+    def to_dict(self) -> dict:
+        return {
+            "project_id": self.project_id,
+            "revision": self.revision,
+            "session_graph": self.session_graph.to_dict(),
+            "arrangement_graph": self.arrangement_graph.to_dict(),
+            "role_graph": self.role_graph.to_dict(),
+            "automation_graph": self.automation_graph.to_dict(),
+            "capability_graph": self.capability_graph.to_dict(),
+            "active_issues": list(self.active_issues),
+            "is_stale": self.is_stale(),
+        }

package/mcp_server/project_brain/refresh.py

@@ -0,0 +1,80 @@
+"""Scoped refresh operations — update specific subgraphs without full rebuild.
+
+Pure computation, zero I/O.
+"""
+
+from __future__ import annotations
+
+import copy
+from typing import Optional
+
+from .arrangement_graph import build_arrangement_graph
+from .models import ProjectState
+from .session_graph import build_session_graph
+
+
+def refresh_tracks(
+    state: ProjectState,
+    track_indices: list[int],
+    session_info: dict,
+) -> ProjectState:
+    """Refresh specific tracks in the session graph without full rebuild.
+
+    Args:
+        state: current ProjectState (not mutated — a new copy is returned).
+        track_indices: which track indices to refresh.
+        session_info: fresh get_session_info output.
+
+    Returns:
+        New ProjectState with updated session graph and bumped revision.
+    """
+    new_state = copy.copy(state)
+    new_state.revision = state.revision + 1
+
+    # Rebuild session graph fully (it's cheap) then mark fresh
+    new_state.session_graph = build_session_graph(session_info)
+    new_state.session_graph.freshness.mark_fresh(new_state.revision)
+
+    # Mark role and automation graphs stale since tracks changed
+    new_state.role_graph = copy.copy(state.role_graph)
+    new_state.role_graph.freshness.mark_stale(
+        f"tracks refreshed: {track_indices}"
+    )
+    new_state.automation_graph = copy.copy(state.automation_graph)
+    new_state.automation_graph.freshness.mark_stale(
+        f"tracks refreshed: {track_indices}"
+    )
+
+    return new_state
+
+
+def refresh_arrangement(
+    state: ProjectState,
+    scenes: list[dict],
+    clip_matrix: list[list[dict]],
+    track_count: int,
+) -> ProjectState:
+    """Refresh the arrangement graph without full rebuild.
+
+    Args:
+        state: current ProjectState (not mutated — a new copy is returned).
+        scenes: fresh scene list.
+        clip_matrix: fresh clip matrix.
+        track_count: total track count.
+
+    Returns:
+        New ProjectState with updated arrangement graph and bumped revision.
+    """
+    new_state = copy.copy(state)
+    new_state.revision = state.revision + 1
+
+    new_state.arrangement_graph = build_arrangement_graph(
+        scenes, clip_matrix, track_count,
+    )
+    new_state.arrangement_graph.freshness.mark_fresh(new_state.revision)
+
+    # Mark role graph stale since arrangement changed
+    new_state.role_graph = copy.copy(state.role_graph)
+    new_state.role_graph.freshness.mark_stale("arrangement refreshed")
+
+    return new_state