Strudel Integration Plan - Option A

cd apps/desktop/cc-echelon/apps/echelon-tauri
npm install @strudel.cycles/core @strudel.cycles/webaudio @strudel.cycles/tonal tone

import { Pattern, repl } from '@strudel.cycles/core'
import { webaudio, initAudio } from '@strudel.cycles/webaudio'
import * as Tone from 'tone'

export class StrudelEngine {
  constructor() {
    this.initialized = false
    this.currentPattern = null
    this.params = {
      kick_gain: 0.8,
      hihat_density: 8,
      bass_cutoff: 400,
      pad_reverb: 0.3,
    }
  }

  async init() {
    if (this.initialized) return

    // Initialize Tone.js and Strudel
    await Tone.start()
    await initAudio()

    // Set up default pattern (house template)
    this.setDefaultPattern()

    this.initialized = true
    console.log('✅ StrudelEngine initialized')
  }

  setDefaultPattern() {
    // Simple house template
    const pattern = `
      stack(
        s("bd").every(4, x => x.fast(2)).gain($kick_gain),
        s("hh*$hihat_density").gain(0.5),
        note("c2 _ _ eb2").s("sawtooth").lpf($bass_cutoff).gain(0.6),
        note("c4 eb4 g4").s("triangle").room($pad_reverb).gain(0.3)
      )
    `.trim()

    this.currentPattern = pattern
    this.evaluate(pattern)
  }

  evaluate(patternCode) {
    try {
      // Substitute parameter values
      let code = patternCode
      for (const [key, value] of Object.entries(this.params)) {
        code = code.replaceAll(`$${key}`, value)
      }

      repl({ defaultOutput: 'webaudio' })(code)
      console.log('🎵 Pattern evaluated:', code.substring(0, 50) + '...')
    } catch (error) {
      console.error('❌ Strudel error:', error)
    }
  }

  // Apply PatternEdit command from Rust
  applyEdit(edit) {
    switch (edit.type) {
      case 'set_param':
        this.setParam(edit.name, edit.value)
        break
      case 'schedule_event':
        this.scheduleEvent(edit.beat_offset, edit.action)
        break
      case 'transform':
        this.applyTransform(edit.track, edit.transform, edit.duration_beats)
        break
      default:
        console.warn('Unknown edit type:', edit.type)
    }

    // Re-evaluate with new params
    this.evaluate(this.currentPattern)
  }

  setParam(name, value) {
    this.params[name] = value
    console.log(`🎛️  ${name} = ${value}`)
  }

  scheduleEvent(beatOffset, action) {
    // Schedule action at future beat
    console.log(`⏰ Scheduled ${action} in ${beatOffset} beats`)
    // TODO: Implement Tone.Transport scheduling
  }

  applyTransform(track, transform, durationBeats) {
    console.log(`🔄 Transform ${transform} on ${track} for ${durationBeats} beats`)
    // TODO: Implement track-specific transforms
  }

  stop() {
    Tone.Transport.stop()
  }
}

import { useEffect, useRef } from 'react'
import { StrudelEngine } from './audio/StrudelEngine'

function App() {
  const strudelRef = useRef(null)

  // Initialize Strudel on mount
  useEffect(() => {
    const initStrudel = async () => {
      if (!strudelRef.current) {
        strudelRef.current = new StrudelEngine()
        await strudelRef.current.init()
      }
    }
    initStrudel()

    return () => {
      strudelRef.current?.stop()
    }
  }, [])

  // ... rest of existing code
}

use serde::{Deserialize, Serialize};
use tauri::State;
use cc_brain::conductor::PatternEdit; // Import from cc-brain

/// Send pattern edit to frontend
#[tauri::command]
pub async fn apply_pattern_edit(
    edit: PatternEdit,
    window: tauri::Window,
) -> Result<(), String> {
    // Emit event to frontend
    window.emit("pattern_edit", &edit)
        .map_err(|e| format!("Failed to emit edit: {}", e))?

    Ok(())
}

/// Get conductor status
#[tauri::command]
pub async fn get_conductor_status(
    state: State<'_, AppState>,
) -> Result<ConductorStatusJson, String> {
    // TODO: Add conductor to AppState
    Ok(ConductorStatusJson {
        section: "Groove".to_string(),
        bar: 0,
        beat: 0,
        tempo_bpm: 120.0,
    })
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConductorStatusJson {
    pub section: String,
    pub bar: u32,
    pub beat: u32,
    pub tempo_bpm: f32,
}

// In main() function, update invoke_handler:
.invoke_handler(tauri::generate_handler![
    commands::get_latent_state,
    commands::get_choreo_moment,
    commands::set_style,
    commands::set_mode,
    commands::get_connection_status,
    commands::apply_pattern_edit,  // NEW
    commands::get_conductor_status, // NEW
])

import { useEffect, useRef } from 'react'
import { listen } from '@tauri-apps/api/event'
import { StrudelEngine } from './audio/StrudelEngine'

function App() {
  const strudelRef = useRef(null)

  useEffect(() => {
    // Initialize Strudel
    const initStrudel = async () => {
      if (!strudelRef.current) {
        strudelRef.current = new StrudelEngine()
        await strudelRef.current.init()
      }
    }
    initStrudel()

    // Listen for PatternEdit events from Rust
    const unlisten = listen('pattern_edit', (event) => {
      if (strudelRef.current) {
        console.log('📨 Received PatternEdit:', event.payload)
        strudelRef.current.applyEdit(event.payload)
      }
    })

    return () => {
      unlisten.then(fn => fn())
      strudelRef.current?.stop()
    }
  }, [])

  // ... rest of existing code
}

use cc_brain::{Conductor, ConductorConfig};
use std::sync::Arc;
use tokio::sync::Mutex as TokioMutex;

pub struct AppState {
    pub latent_state: Arc<Mutex<LatentState>>,
    pub cloud_client: Arc<CloudClient>,
    pub sc_client: Option<SharedSuperColliderClient>,
    pub style_index: Arc<AtomicU8>,
    pub mode_index: Arc<AtomicU8>,
    pub sc_enabled: bool,
    pub conductor: Arc<TokioMutex<Conductor>>, // NEW
}

fn main() {
    // ... existing setup ...

    // Create conductor
    let conductor_config = ConductorConfig {
        tempo_bpm: 120.0,
        param_cooldown_ms: 200,
        event_cooldown_ms: 500,
        section_cooldown_ms: 4000,
        max_pending_edits: 20,
        pattern_coder_url: None, // No ML model yet, use rules
    };
    let conductor = Arc::new(TokioMutex::new(
        Conductor::new(conductor_config)
    ));

    let app_state = AppState {
        latent_state,
        cloud_client: client,
        sc_client,
        style_index,
        mode_index,
        sc_enabled,
        conductor, // NEW
    };

    // ... rest of main
}

use std::sync::Arc;
use std::time::Duration;
use tokio::sync::Mutex;
use tauri::Window;
use cc_brain::{Conductor, LatentTrajectory};
use motion_bridge::LatentState;

pub fn spawn_conductor_thread(
    conductor: Arc<Mutex<Conductor>>,
    latent_rx: std::sync::mpsc::Receiver<LatentState>,
    window: Window,
) {
    tokio::spawn(async move {
        println!("🎼 Conductor thread started");

        loop {
            // Receive latent state
            match latent_rx.recv_timeout(Duration::from_millis(100)) {
                Ok(latent) => {
                    // TODO: Convert LatentState → LatentTrajectory with rehearsal

                    // For now, just tick the conductor
                    let mut cond = conductor.lock().await;
                    cond.tick(std::time::Instant::now());

                    // Get any pending edits
                    if let Some(edits) = cond.get_pending_edits() {
                        for edit in edits {
                            // Send to frontend
                            if let Err(e) = window.emit("pattern_edit", &edit) {
                                eprintln!("Failed to emit edit: {}", e);
                            }
                        }
                    }
                }
                Err(std::sync::mpsc::RecvTimeoutError::Timeout) => continue,
                Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => break,
            }
        }
    });
}

impl Conductor {
    /// Generate pattern edits based on current section and trajectory
    pub fn generate_edits_from_section(&mut self) -> Vec<PatternEdit> {
        let mut edits = Vec::new();

        match self.section {
            MusicSection::Intro => {
                // Intro: sparse kick, minimal hats
                edits.push(PatternEdit::SetParam {
                    name: "kick_gain".to_string(),
                    value: 0.6,
                    curve: None,
                    transition_beats: Some(4.0),
                });
                edits.push(PatternEdit::SetParam {
                    name: "hihat_density".to_string(),
                    value: 4.0,
                    curve: None,
                    transition_beats: Some(4.0),
                });
            }
            MusicSection::Groove => {
                // Groove: full kick, medium hats
                edits.push(PatternEdit::SetParam {
                    name: "kick_gain".to_string(),
                    value: 0.8,
                    curve: None,
                    transition_beats: Some(2.0),
                });
                edits.push(PatternEdit::SetParam {
                    name: "hihat_density".to_string(),
                    value: 8.0,
                    curve: None,
                    transition_beats: Some(2.0),
                });
            }
            MusicSection::Build => {
                // Build: increase tension
                edits.push(PatternEdit::SetParam {
                    name: "hihat_density".to_string(),
                    value: 16.0,
                    curve: Some("exponential".to_string()),
                    transition_beats: Some(8.0),
                });
                edits.push(PatternEdit::SetParam {
                    name: "bass_cutoff".to_string(),
                    value: 1200.0,
                    curve: Some("linear".to_string()),
                    transition_beats: Some(8.0),
                });
            }
            MusicSection::Climax => {
                // Climax: everything maxed
                edits.push(PatternEdit::SetParam {
                    name: "kick_gain".to_string(),
                    value: 1.0,
                    curve: None,
                    transition_beats: Some(0.5),
                });
                edits.push(PatternEdit::ScheduleEvent {
                    beat_offset: 0.0,
                    action: "crash".to_string(),
                    intensity: Some(1.0),
                });
            }
            MusicSection::Breakdown => {
                // Breakdown: drop drums, emphasize pads
                edits.push(PatternEdit::SetParam {
                    name: "kick_gain".to_string(),
                    value: 0.0,
                    curve: None,
                    transition_beats: Some(1.0),
                });
                edits.push(PatternEdit::SetParam {
                    name: "pad_reverb".to_string(),
                    value: 0.8,
                    curve: None,
                    transition_beats: Some(4.0),
                });
            }
            MusicSection::Outro => {
                // Outro: fade everything
                edits.push(PatternEdit::SetParam {
                    name: "kick_gain".to_string(),
                    value: 0.3,
                    curve: Some("exponential".to_string()),
                    transition_beats: Some(16.0),
                });
            }
        }

        edits
    }
}

1. iOS Phone → WebSocket → cc-mcs (cloud/local)
2. cc-mcs → LatentState → echelon-tauri (Tauri backend)
3. echelon-tauri → Conductor.tick()
4. Conductor → PatternEdit (based on section rules)
5. Tauri → emit("pattern_edit")
6. React → StrudelEngine.applyEdit()
7. Strudel → Tone.js → Audio Output ✨

apps/desktop/cc-echelon/
├── apps/echelon-tauri/
│   ├── src/
│   │   ├── audio/
│   │   │   └── StrudelEngine.js          # NEW - Strudel runtime wrapper
│   │   └── App.jsx                       # MODIFIED - listen for pattern_edit events
│   ├── src-tauri/src/
│   │   ├── main.rs                       # MODIFIED - add Conductor to AppState
│   │   ├── commands.rs                   # MODIFIED - add pattern_edit commands
│   │   └── conductor_thread.rs           # NEW - conductor update loop
│   └── package.json                      # MODIFIED - add Strudel deps
└── crates/
    └── cc-brain/src/
        └── conductor.rs                  # MODIFIED - add section→pattern rules