@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

package/rust/cli/play/commands.rs

@@ -0,0 +1,324 @@
+use crate::config::driver::ProjectConfig;
+use devalang_utils::logger::{LogLevel, Logger};
+use std::{sync::mpsc::channel, thread};
+
+pub use crate::cli::play::io::wav_duration_seconds;
+pub use crate::cli::play::realtime::{
+    RtContext, join_realtime_runner, start_realtime_runner, stop_realtime_runner,
+};
+
+use super::process::process_play;
+use super::utils::{files_changed, snapshot_files};
+
+use crate::core::audio::player::AudioPlayer;
+
+#[cfg(feature = "cli")]
+pub fn handle_play_command(
+    config: Option<ProjectConfig>,
+    entry: Option<String>,
+    output: Option<String>,
+    watch: bool,
+    repeat: bool,
+    debug: bool,
+) -> Result<(), String> {
+    let logger = Logger::new();
+
+    let entry_path = entry
+        .or_else(|| config.as_ref().and_then(|c| c.defaults.entry.clone()))
+        .unwrap_or_default();
+
+    let output_path = output
+        .or_else(|| config.as_ref().and_then(|c| c.defaults.output.clone()))
+        .unwrap_or_default();
+
+    let fetched_repeat = if repeat {
+        true
+    } else {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.repeat)
+            .unwrap_or(false)
+    };
+
+    if entry_path.is_empty() || output_path.is_empty() {
+        logger.log_message(LogLevel::Error, "Entry or output path not specified.");
+        return Err("missing entry or output".to_string());
+    }
+
+    let entry_file = match crate::core::utils::path::find_entry_file(&entry_path) {
+        Some(p) => p,
+        None => {
+            logger.log_message(LogLevel::Error, "index.deva not found");
+            return Err("index.deva not found".to_string());
+        }
+    };
+
+    let audio_file = format!(
+        "{}/audio/index.wav",
+        crate::core::utils::path::normalize_path(&output_path)
+    );
+    let mut audio_player = AudioPlayer::new();
+
+    if watch && fetched_repeat {
+        logger.log_message(
+            LogLevel::Error,
+            "Watch and repeat cannot be used together. Use repeat instead.",
+        );
+        return Err("invalid options: watch and repeat cannot be combined".to_string());
+    }
+
+    if watch {
+        let (tx, rx) = channel::<()>();
+
+        // Thread 1 : Watcher sending changes
+        let entry_clone = entry_path.clone();
+        thread::spawn(move || {
+            let _ = devalang_utils::watcher::watch_directory(entry_clone, move || {
+                let _ = tx.send(()); // signal a change
+            });
+        });
+
+        // Main thread: build + play in a loop
+        let (bpm, entry_stmts, variables, functions, global_store) =
+            process_play(&config, &entry_file, &output_path, debug)?;
+        audio_player.play_file_once(&audio_file);
+        // Estimate duration: base on statement count plus extra for loop iterations (1 beat per iter)
+        let loop_iters: usize = entry_stmts
+            .iter()
+            .map(|s| match &s.kind {
+                crate::core::parser::statement::StatementKind::Loop => {
+                    use devalang_types::Value;
+                    if let Value::Map(m) = &s.value {
+                        if let Some(Value::Array(items)) = m.get("array") {
+                            items.len()
+                        } else if let Some(Value::Number(n)) = m.get("iterator") {
+                            (*n).max(0.0) as usize
+                        } else {
+                            0
+                        }
+                    } else {
+                        0
+                    }
+                }
+                _ => 0,
+            })
+            .sum();
+        let est_beats = (entry_stmts.len() as f32) + (loop_iters as f32);
+        let est_by_len = ((60.0 / bpm).max(0.01) * est_beats).max(1.0);
+        let total_secs = wav_duration_seconds(&audio_file)
+            .unwrap_or(0.0)
+            .max(est_by_len);
+        let mut rt_runner = Some(start_realtime_runner(
+            RtContext {
+                bpm,
+                entry_stmts,
+                variables,
+                functions,
+                global_store,
+            },
+            total_secs,
+        ));
+
+        logger.log_message(
+            LogLevel::Watcher,
+            "Watching for changes... Press Ctrl+C to exit.",
+        );
+
+        while rx.recv().is_ok() {
+            logger.log_message(LogLevel::Watcher, "Change detected, rebuilding...");
+
+            // Stop previous real-time runner before restarting playback
+            stop_realtime_runner(&mut rt_runner);
+
+            let (bpm, entry_stmts, variables, functions, global_store) =
+                match process_play(&config, &entry_file, &output_path, debug) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        logger.log_message(LogLevel::Error, &format!("Rebuild failed: {}", e));
+                        continue;
+                    }
+                };
+
+            logger.log_message(LogLevel::Info, "🎵 Playback started (once mode)...");
+
+            audio_player.play_file_once(&audio_file);
+            let loop_iters: usize = entry_stmts
+                .iter()
+                .map(|s| match &s.kind {
+                    crate::core::parser::statement::StatementKind::Loop => {
+                        use devalang_types::Value;
+                        if let Value::Map(m) = &s.value {
+                            if let Some(Value::Array(items)) = m.get("array") {
+                                items.len()
+                            } else if let Some(Value::Number(n)) = m.get("iterator") {
+                                (*n).max(0.0) as usize
+                            } else {
+                                0
+                            }
+                        } else {
+                            0
+                        }
+                    }
+                    _ => 0,
+                })
+                .sum();
+            let est_beats = (entry_stmts.len() as f32) + (loop_iters as f32);
+            let est_by_len = ((60.0 / bpm).max(0.01) * est_beats).max(1.0);
+            let total_secs = wav_duration_seconds(&audio_file)
+                .unwrap_or(0.0)
+                .max(est_by_len);
+            rt_runner = Some(start_realtime_runner(
+                RtContext {
+                    bpm,
+                    entry_stmts: entry_stmts.clone(),
+                    variables: variables.clone(),
+                    functions: functions.clone(),
+                    global_store: global_store.clone(),
+                },
+                total_secs,
+            ));
+        }
+    } else if fetched_repeat {
+        // Initial build to start from a clean slate
+        let (bpm, entry_stmts, variables, functions, global_store) =
+            process_play(&config, &entry_file, &output_path, debug)?;
+
+        logger.log_message(LogLevel::Info, "🎵 Playback started (repeat mode)...");
+
+        let mut last_snapshot = snapshot_files(&entry_path);
+        let mut audio_player = AudioPlayer::new();
+        audio_player.play_file_once(&audio_file);
+
+        let loop_iters: usize = entry_stmts
+            .iter()
+            .map(|s| match &s.kind {
+                crate::core::parser::statement::StatementKind::Loop => {
+                    use devalang_types::Value;
+
+                    if let Value::Map(m) = &s.value {
+                        if let Some(Value::Array(items)) = m.get("array") {
+                            items.len()
+                        } else if let Some(Value::Number(n)) = m.get("iterator") {
+                            (*n).max(0.0) as usize
+                        } else {
+                            0
+                        }
+                    } else {
+                        0
+                    }
+                }
+                _ => 0,
+            })
+            .sum();
+        let est_beats = (entry_stmts.len() as f32) + (loop_iters as f32);
+        let est_by_len = ((60.0 / bpm).max(0.01) * est_beats).max(1.0);
+        let total_secs = wav_duration_seconds(&audio_file)
+            .unwrap_or(0.0)
+            .max(est_by_len);
+        let mut rt_runner = Some(start_realtime_runner(
+            RtContext {
+                bpm,
+                entry_stmts: entry_stmts.clone(),
+                variables: variables.clone(),
+                functions: functions.clone(),
+                global_store: global_store.clone(),
+            },
+            total_secs,
+        ));
+
+        loop {
+            let current_snapshot = snapshot_files(&entry_path);
+            let has_changed = files_changed(&last_snapshot, &current_snapshot);
+
+            if has_changed {
+                logger.log_message(
+                    LogLevel::Info,
+                    "Change detected, rebuilding in background...",
+                );
+                let entry_file = entry_file.clone();
+                let output_path = output_path.clone();
+                let config_clone = config.clone();
+
+                // Rebuild in a separate thread
+                std::thread::spawn(move || {
+                    if let Err(e) = process_play(&config_clone, &entry_file, &output_path, debug) {
+                        eprintln!("Rebuild failed in background: {}", e);
+                    }
+                });
+
+                last_snapshot = current_snapshot;
+            }
+
+            // Wait for the audio to finish
+            audio_player.wait_until_end();
+            // Stop the current real-time runner
+            stop_realtime_runner(&mut rt_runner);
+
+            // Then replay the audio (rebuilt or not)
+            audio_player.play_file_once(&audio_file);
+            let loop_iters: usize = entry_stmts
+                .iter()
+                .map(|s| match &s.kind {
+                    crate::core::parser::statement::StatementKind::Loop => {
+                        use devalang_types::Value;
+                        if let Value::Map(m) = &s.value {
+                            if let Some(Value::Array(items)) = m.get("array") {
+                                items.len()
+                            } else if let Some(Value::Number(n)) = m.get("iterator") {
+                                (*n).max(0.0) as usize
+                            } else {
+                                0
+                            }
+                        } else {
+                            0
+                        }
+                    }
+                    _ => 0,
+                })
+                .sum();
+            let est_beats = (entry_stmts.len() as f32) + (loop_iters as f32);
+            let est_by_len = ((60.0 / bpm).max(0.01) * est_beats).max(1.0);
+            let total_secs = wav_duration_seconds(&audio_file)
+                .unwrap_or(0.0)
+                .max(est_by_len);
+            rt_runner = Some(start_realtime_runner(
+                RtContext {
+                    bpm,
+                    entry_stmts: entry_stmts.clone(),
+                    variables: variables.clone(),
+                    functions: functions.clone(),
+                    global_store: global_store.clone(),
+                },
+                total_secs,
+            ));
+        }
+    } else {
+        // Single execution
+        let (bpm, entry_stmts, variables, functions, global_store) =
+            process_play(&config, &entry_file, &output_path, debug)?;
+
+        logger.log_message(LogLevel::Info, "🎵 Playback started (once mode)...");
+
+        audio_player.play_file_once(&audio_file);
+
+        let est_by_len = ((60.0 / bpm).max(0.01) * (entry_stmts.len() as f32)).max(1.0);
+        let total_secs = wav_duration_seconds(&audio_file)
+            .unwrap_or(0.0)
+            .max(est_by_len);
+        let mut rt_runner = Some(start_realtime_runner(
+            RtContext {
+                bpm,
+                entry_stmts,
+                variables,
+                functions,
+                global_store,
+            },
+            total_secs,
+        ));
+
+        audio_player.wait_until_end();
+        // Let the runner finish naturally to execute all remaining statements (e.g., loop prints)
+        join_realtime_runner(&mut rt_runner);
+    }
+    Ok(())
+}

package/rust/cli/play/io.rs

@@ -0,0 +1,17 @@
+use hound;
+
+pub fn wav_duration_seconds(path: &str) -> Option<f32> {
+    if let Ok(reader) = hound::WavReader::open(path) {
+        let spec = reader.spec();
+        let len = reader.len();
+        if spec.sample_rate == 0 {
+            return None;
+        }
+        let channels = spec.channels.max(1) as u32;
+        let frames = len / channels;
+        let dur = (frames as f32) / (spec.sample_rate as f32);
+        Some(dur)
+    } else {
+        None
+    }
+}

package/rust/cli/play/mod.rs

@@ -0,0 +1,5 @@
+pub mod commands;
+pub mod io;
+pub mod process;
+pub mod realtime;
+pub mod utils;

package/rust/cli/play/process.rs

@@ -0,0 +1,150 @@
+use crate::{
+    config::driver::ProjectConfig,
+    core::{
+        builder::Builder,
+        debugger::{
+            lexer::write_lexer_log_file,
+            module::{write_module_function_log_file, write_module_variable_log_file},
+            preprocessor::write_preprocessor_log_file,
+            store::{write_function_log_file, write_variables_log_file},
+        },
+        preprocessor::loader::ModuleLoader,
+        store::global::GlobalStore,
+        utils::path::normalize_path,
+    },
+};
+use devalang_utils::{
+    logger::{LogLevel, Logger},
+    spinner::start_spinner,
+};
+
+pub fn process_play(
+    _config: &Option<ProjectConfig>,
+    entry_file: &str,
+    output: &str,
+    debug: bool,
+) -> Result<
+    (
+        f32,
+        Vec<crate::core::parser::statement::Statement>,
+        crate::core::store::variable::VariableTable,
+        crate::core::store::function::FunctionTable,
+        crate::core::store::global::GlobalStore,
+    ),
+    String,
+> {
+    let spinner = start_spinner("Building...");
+
+    let normalized_entry = normalize_path(entry_file);
+    let normalized_output_dir = normalize_path(output);
+
+    let duration = std::time::Instant::now();
+    let mut global_store = GlobalStore::new();
+    let loader = ModuleLoader::new(&normalized_entry, &normalized_output_dir);
+    let (modules_tokens, modules_statements) = loader.load_all_modules(&mut global_store);
+
+    // Try to detect initial BPM from statements (fallback to 120.0)
+    let mut detected_bpm: f32 = 120.0;
+    let mut entry_statements: Vec<crate::core::parser::statement::Statement> = Vec::new();
+    // Prefer the entry module if present
+    if let Some(entry_stmts) = modules_statements.get(&normalized_entry) {
+        entry_statements = entry_stmts.clone();
+        for stmt in entry_stmts {
+            if let crate::core::parser::statement::StatementKind::Tempo = &stmt.kind {
+                use devalang_types::Value;
+                if let Value::Number(n) = &stmt.value {
+                    detected_bpm = *n;
+                    break;
+                }
+            }
+        }
+    }
+    // If still default, scan other modules for a tempo directive
+    if (detected_bpm - 120.0).abs() < f32::EPSILON {
+        'outer: for (_name, stmts) in modules_statements.iter() {
+            for stmt in stmts {
+                if let crate::core::parser::statement::StatementKind::Tempo = &stmt.kind {
+                    use devalang_types::Value;
+                    if let Value::Number(n) = &stmt.value {
+                        detected_bpm = *n;
+                        break 'outer;
+                    }
+                }
+            }
+        }
+    }
+
+    // SECTION Write logs
+    if debug {
+        for (module_path, module) in global_store.modules.clone() {
+            write_module_variable_log_file(
+                &normalized_output_dir,
+                &module_path,
+                &module.variable_table,
+            );
+            write_module_function_log_file(
+                &normalized_output_dir,
+                &module_path,
+                &module.function_table,
+            );
+        }
+
+        write_lexer_log_file(
+            &normalized_output_dir,
+            "lexer_tokens.log",
+            modules_tokens.clone(),
+        );
+        write_preprocessor_log_file(
+            &normalized_output_dir,
+            "resolved_statements.log",
+            modules_statements.clone(),
+        );
+        write_variables_log_file(
+            &normalized_output_dir,
+            "global_variables.log",
+            global_store.variables.clone(),
+        );
+        write_function_log_file(
+            &normalized_output_dir,
+            "global_functions.log",
+            global_store.functions.clone(),
+        );
+    }
+
+    // SECTION Detect errors before building (like build.rs)
+    let all_errors = crate::core::error::collect_all_errors_with_modules(&modules_statements);
+    let (warnings, criticals) = crate::core::error::partition_errors(all_errors);
+    crate::core::error::log_errors_with_stack("Play", &warnings, &criticals);
+    if !criticals.is_empty() {
+        spinner.finish_and_clear();
+        return Err(format!(
+            "play failed with {} critical error(s): {}",
+            criticals.len(),
+            criticals[0].message
+        ));
+    }
+
+    // SECTION Building AST and Audio
+    let builder = Builder::new();
+    builder.build_ast(&modules_statements, output, false);
+    builder.build_audio(&modules_statements, output, &mut global_store);
+
+    // SECTION Logging
+    let logger = Logger::new();
+    let success_message = format!(
+        "Build completed successfully in {:.2?}. Output files written to: '{}'",
+        duration.elapsed(),
+        normalized_output_dir
+    );
+
+    spinner.finish_and_clear();
+    logger.log_message(LogLevel::Success, &success_message);
+
+    Ok((
+        detected_bpm,
+        entry_statements,
+        global_store.variables.clone(),
+        global_store.functions.clone(),
+        global_store,
+    ))
+}

package/rust/cli/play/realtime.rs

@@ -0,0 +1,91 @@
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Duration;
+
+use devalang_types::Value;
+
+pub struct RtRunner {
+    pub stop: Arc<AtomicBool>,
+    pub handle: std::thread::JoinHandle<()>,
+}
+
+pub struct RtContext {
+    pub bpm: f32,
+    pub entry_stmts: Vec<crate::core::parser::statement::Statement>,
+    pub variables: crate::core::store::variable::VariableTable,
+    pub functions: crate::core::store::function::FunctionTable,
+    pub global_store: crate::core::store::global::GlobalStore,
+}
+
+pub fn start_realtime_runner(ctx: RtContext, total_secs: f32) -> RtRunner {
+    use crate::core::audio::engine::AudioEngine;
+    use crate::core::audio::interpreter::driver::execute_audio_block;
+    use crate::core::parser::statement::StatementKind;
+    use devalang_utils::logger::Logger;
+
+    let stop = Arc::new(AtomicBool::new(false));
+    let stop_clone = stop.clone();
+
+    let handle = std::thread::spawn(move || {
+        let _logger = Logger::new();
+        let bpm = if ctx.bpm > 0.0 { ctx.bpm } else { 120.0 };
+        let beat_secs = 60.0f32 / bpm;
+        let mut elapsed = 0.0f32;
+
+        let mut variables = ctx.variables.clone();
+        variables.set("__rt".to_string(), Value::Boolean(true));
+        let functions = ctx.functions.clone();
+        let _global_store = ctx.global_store.clone();
+        let mut audio_engine = AudioEngine::new("rt".to_string());
+
+        let i: usize = 0;
+        let mut _current_loop: Option<()> = None; // simplified state
+        let mut _beat_index: u64 = 0;
+        while elapsed + 1e-3 < total_secs && i < ctx.entry_stmts.len() {
+            if stop_clone.load(Ordering::Relaxed) {
+                break;
+            }
+
+            std::thread::sleep(Duration::from_secs_f32(beat_secs));
+            elapsed += beat_secs;
+            _beat_index += 1;
+            if stop_clone.load(Ordering::Relaxed) {
+                break;
+            }
+
+            // Only fire periodic handlers when not in a loop - simplified
+            if let Some(handlers) = ctx.global_store.get_event_handlers("beat") {
+                for h in handlers {
+                    if let StatementKind::On { body, .. } = &h.kind {
+                        let _ = execute_audio_block(
+                            &mut audio_engine,
+                            &ctx.global_store,
+                            variables.clone(),
+                            functions.clone(),
+                            body,
+                            bpm,
+                            60.0 / bpm,
+                            0.0,
+                            0.0,
+                        );
+                    }
+                }
+            }
+        }
+    });
+
+    RtRunner { stop, handle }
+}
+
+pub fn stop_realtime_runner(runner_opt: &mut Option<RtRunner>) {
+    if let Some(r) = runner_opt.take() {
+        r.stop.store(true, Ordering::Relaxed);
+        let _ = r.handle.join();
+    }
+}
+
+pub fn join_realtime_runner(runner_opt: &mut Option<RtRunner>) {
+    if let Some(r) = runner_opt.take() {
+        let _ = r.handle.join();
+    }
+}

package/rust/cli/play/utils.rs

@@ -0,0 +1,23 @@
+use std::collections::HashMap;
+use std::fs;
+use std::path::Path;
+
+pub fn snapshot_files<P: AsRef<Path>>(dir: P) -> HashMap<String, u64> {
+    let mut map = HashMap::new();
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            if let Ok(meta) = entry.metadata() {
+                if let Ok(mtime) = meta.modified() {
+                    if let Ok(duration) = mtime.duration_since(std::time::UNIX_EPOCH) {
+                        map.insert(entry.path().display().to_string(), duration.as_secs());
+                    }
+                }
+            }
+        }
+    }
+    map
+}
+
+pub fn files_changed(old: &HashMap<String, u64>, new: &HashMap<String, u64>) -> bool {
+    old != new
+}

package/rust/cli/{telemetry.rs → telemetry/commands.rs}

@@ -1,9 +1,9 @@
-use crate::config::settings::set_user_config_bool;
-use crate::utils::logger::{LogLevel, Logger};
+use crate::config::settings::set_user_config_value;
+use devalang_utils::logger::{LogLevel, Logger};
 
 #[cfg(feature = "cli")]
 pub async fn handle_telemetry_enable_command() -> Result<(), String> {
-    set_user_config_bool("telemetry", true);
+    set_user_config_value("telemetry", serde_json::Value::Bool(true));
 
     let logger = Logger::new();
     logger.log_message(LogLevel::Info, "Telemetry has been enabled.");
@@ -13,7 +13,7 @@ pub async fn handle_telemetry_enable_command() -> Result<(), String> {
 
 #[cfg(feature = "cli")]
 pub async fn handle_telemetry_disable_command() -> Result<(), String> {
-    set_user_config_bool("telemetry", false);
+    set_user_config_value("telemetry", serde_json::Value::Bool(false));
 
     let logger = Logger::new();
     logger.log_message(LogLevel::Info, "Telemetry has been disabled.");