@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/cli/play/commands.rs

@@ -1,375 +0,0 @@
-use crate::config::driver::ProjectConfig;
-use devalang_utils::logger::{LogLevel, Logger};
-use devalang_utils::path::{find_entry_file, normalize_path};
-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>,
-    audio_format: crate::cli::parser::AudioFormat,
-    sample_rate: u32,
-    watch: bool,
-    repeat: bool,
-    debug: bool,
-) -> Result<(), String> {
-    let logger = Logger::new();
-
-    // Determine final audio_format and sample_rate, preferring CLI values but falling back to config defaults
-    let mut final_audio_format = audio_format;
-    let mut final_sample_rate = sample_rate;
-    if let Some(cfg) = config.as_ref() {
-        if let Some(af) = cfg.defaults.audio_format.as_ref() {
-            let af_low = af.to_lowercase();
-            final_audio_format = match af_low.as_str() {
-                "wav24" => crate::cli::parser::AudioFormat::Wav24,
-                "wav32" => crate::cli::parser::AudioFormat::Wav32,
-                _ => crate::cli::parser::AudioFormat::Wav16,
-            };
-        }
-        if let Some(sr) = cfg.defaults.sample_rate {
-            // Only override if CLI provided a 0 or unrealistic value (we assume CLI provides a valid value)
-            if final_sample_rate == 0 {
-                final_sample_rate = sr;
-            }
-        }
-    }
-
-    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 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", 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,
-            final_audio_format,
-            final_sample_rate,
-            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,
-                final_audio_format,
-                final_sample_rate,
-                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,
-            final_audio_format,
-            final_sample_rate,
-            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,
-                        final_audio_format,
-                        final_sample_rate,
-                        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,
-            final_audio_format,
-            final_sample_rate,
-            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

@@ -1,17 +0,0 @@
-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

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

package/rust/cli/play/process.rs

@@ -1,159 +0,0 @@
-use crate::{
-    config::driver::ProjectConfig,
-    core::{
-        builder::Builder,
-        debugger::{
-            lexer::write_lexer_log_file,
-            logs::{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,
-    },
-};
-use devalang_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,
-    audio_format: crate::cli::parser::AudioFormat,
-    sample_rate: u32,
-    debug: bool,
-) -> Result<
-    (
-        f32,
-        Vec<crate::core::parser::statement::Statement>,
-        devalang_types::VariableTable,
-        devalang_types::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);
-    let audio_format_str = format!("{:?}", audio_format);
-    builder.build_audio(
-        &modules_statements,
-        output,
-        &mut global_store,
-        Some(audio_format_str),
-        Some(sample_rate),
-    );
-
-    // 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

@@ -1,91 +0,0 @@
-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: devalang_types::store::VariableTable,
-    pub functions: devalang_types::store::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

@@ -1,23 +0,0 @@
-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/commands.rs

@@ -1,22 +0,0 @@
-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_value("telemetry", serde_json::Value::Bool(true));
-
-    let logger = Logger::new();
-    logger.log_message(LogLevel::Info, "Telemetry has been enabled.");
-
-    Ok(())
-}
-
-#[cfg(feature = "cli")]
-pub async fn handle_telemetry_disable_command() -> Result<(), String> {
-    set_user_config_value("telemetry", serde_json::Value::Bool(false));
-
-    let logger = Logger::new();
-    logger.log_message(LogLevel::Info, "Telemetry has been disabled.");
-
-    Ok(())
-}