@devaloop/devalang 0.0.1-beta.3 → 0.1.2

package/rust/cli/telemetry/event_creator.rs

@@ -1,80 +0,0 @@
-use crate::config::settings::get_user_config;
-use devalang_types::{
-    TelemetryErrorLevel as SharedTelemetryErrorLevel, TelemetryEvent as SharedTelemetryEvent,
-};
-use uuid::Uuid;
-
-pub type TelemetryEvent = SharedTelemetryEvent;
-pub type TelemetryErrorLevel = SharedTelemetryErrorLevel;
-
-pub trait TelemetryEventExt {
-    fn set_timestamp(&mut self, timestamp: String);
-    fn set_duration(&mut self, duration: u64);
-    fn set_success(&mut self, success: bool);
-    fn set_error(
-        &mut self,
-        level: TelemetryErrorLevel,
-        message: Option<String>,
-        exit_code: Option<i32>,
-    );
-}
-
-impl TelemetryEventExt for SharedTelemetryEvent {
-    fn set_timestamp(&mut self, timestamp: String) {
-        self.timestamp = timestamp;
-    }
-
-    fn set_duration(&mut self, duration: u64) {
-        self.duration = duration;
-    }
-
-    fn set_success(&mut self, success: bool) {
-        self.success = success;
-    }
-
-    fn set_error(
-        &mut self,
-        level: TelemetryErrorLevel,
-        message: Option<String>,
-        exit_code: Option<i32>,
-    ) {
-        self.error_level = level;
-        self.error_message = message;
-        self.exit_code = exit_code;
-    }
-}
-
-pub struct TelemetryEventCreator {
-    pub events: Vec<TelemetryEvent>,
-}
-
-impl TelemetryEventCreator {
-    pub fn new() -> Self {
-        TelemetryEventCreator { events: Vec::new() }
-    }
-
-    pub fn create_event(&mut self, event: TelemetryEvent) {
-        self.events.push(event.clone());
-    }
-
-    pub fn get_base_event(&self) -> TelemetryEvent {
-        let uuid = match get_user_config() {
-            Some(cfg) if !cfg.telemetry.uuid.is_empty() => cfg.telemetry.uuid.clone(),
-            _ => Uuid::new_v4().to_string(),
-        };
-
-        TelemetryEvent {
-            uuid,
-            cli_version: env!("CARGO_PKG_VERSION").to_string(),
-            os: std::env::consts::OS.to_string(),
-            command: std::env::args().collect::<Vec<_>>(),
-            project_info: None,
-            error_level: TelemetryErrorLevel::None,
-            error_message: None,
-            exit_code: None,
-            timestamp: chrono::Utc::now().to_string(),
-            duration: 0,
-            success: true,
-        }
-    }
-}

package/rust/cli/telemetry/mod.rs

@@ -1,3 +0,0 @@
-pub mod commands;
-pub mod event_creator;
-pub mod send;

package/rust/cli/telemetry/send.rs

@@ -1,51 +0,0 @@
-use std::time::Duration;
-
-use crate::{config::settings::get_user_config, web::api::get_api_url};
-use devalang_types::{TelemetryEvent, TelemetrySendError};
-
-pub async fn send_telemetry_event(event: &TelemetryEvent) -> Result<(), TelemetrySendError> {
-    if let Some(cfg) = get_user_config() {
-        if cfg.telemetry.enabled == false {
-            return Ok(());
-        }
-    } else {
-        return Ok(());
-    }
-
-    let telemetry_url = format!("{}/v1/telemetry/send", get_api_url());
-    let client = reqwest::Client::builder()
-        .timeout(Duration::from_secs(5))
-        .build()
-        .map_err(|e| TelemetrySendError::Http(format!("client build error: {}", e)))?;
-
-    let mut last_err: Option<String> = None;
-    for (i, delay_ms) in [0u64, 250, 500, 1000].iter().enumerate() {
-        if *delay_ms > 0 {
-            tokio::time::sleep(Duration::from_millis(*delay_ms)).await;
-        }
-
-        let res = client
-            .post(telemetry_url.clone())
-            .json(event)
-            .send()
-            .await
-            .and_then(|r| r.error_for_status());
-
-        match res {
-            Ok(_) => {
-                return Ok(());
-            }
-            Err(err) => {
-                last_err = Some(err.to_string());
-
-                if i == 3 {
-                    break;
-                }
-            }
-        }
-    }
-
-    Err(TelemetrySendError::Http(
-        last_err.unwrap_or_else(|| "unknown error".to_string()),
-    ))
-}

package/rust/cli/template/commands.rs

@@ -1,69 +0,0 @@
-use devalang_utils::file::format_file_size;
-use include_dir::{Dir, DirEntry, include_dir};
-
-static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
-
-#[cfg(feature = "cli")]
-pub fn handle_template_list_command() {
-    let available_templates = get_available_templates();
-
-    println!("📦 Available templates ({}) :\n", available_templates.len());
-
-    for dir in available_templates {
-        println!("• {}", dir);
-    }
-
-    println!("\nUsage : devalang init --name <project-name> --template <template-name>");
-}
-
-#[cfg(feature = "cli")]
-pub fn handle_template_info_command(name: String) {
-    let template_dir = TEMPLATES_DIR.get_dir(name.clone()).unwrap_or_else(|| {
-        println!("❌ The template '{}' is not found.", name);
-
-        std::process::exit(1);
-    });
-
-    let mut file_count = 0;
-    let mut dir_count = 0;
-    let mut total_size: u64 = 0;
-
-    fn walk(dir: &Dir, file_count: &mut u32, dir_count: &mut u32, total_size: &mut u64) {
-        for entry in dir.entries() {
-            match entry {
-                DirEntry::File(file) => {
-                    *file_count += 1;
-                    *total_size += file.contents().len() as u64;
-                }
-                DirEntry::Dir(subdir) => {
-                    *dir_count += 1;
-                    walk(subdir, file_count, dir_count, total_size);
-                }
-            }
-        }
-    }
-
-    walk(
-        template_dir,
-        &mut file_count,
-        &mut dir_count,
-        &mut total_size,
-    );
-
-    println!("📦 Template : {}", name);
-    println!("📂 Content  : {file_count} file(s), {dir_count} folder(s)");
-    println!("💾 Size     : {}", format_file_size(total_size));
-}
-
-pub fn get_available_templates() -> Vec<String> {
-    TEMPLATES_DIR
-        .dirs()
-        .map(|dir| {
-            dir.path()
-                .file_name()
-                .unwrap()
-                .to_string_lossy()
-                .to_string()
-        })
-        .collect()
-}

package/rust/cli/template/mod.rs

@@ -1 +0,0 @@
-pub mod commands;

package/rust/cli/update/commands.rs

@@ -1,6 +0,0 @@
-pub async fn handle_update_command(
-    _only: Option<String>,
-) -> Result<(), Box<dyn std::error::Error>> {
-    println!("Updates are not yet implemented.");
-    Ok(())
-}

package/rust/cli/update/mod.rs

@@ -1 +0,0 @@
-pub mod commands;

package/rust/config/driver.rs

@@ -1,112 +0,0 @@
-use devalang_types::{
-    PluginEntry as SharedPluginEntry, ProjectConfig as SharedProjectConfig,
-    ProjectConfigBankEntry as SharedProjectConfigBankEntry,
-    ProjectConfigDefaults as SharedProjectConfigDefaults,
-    ProjectConfigPluginEntry as SharedProjectConfigPluginEntry,
-};
-use devalang_utils::path as path_utils;
-use std::path::PathBuf;
-
-pub type ProjectConfig = SharedProjectConfig;
-pub type ProjectConfigDefaults = SharedProjectConfigDefaults;
-pub type ProjectConfigBankEntry = SharedProjectConfigBankEntry;
-pub type ProjectConfigPluginEntry = SharedProjectConfigPluginEntry;
-pub type PluginEntry = SharedPluginEntry;
-
-pub trait ProjectConfigExt {
-    fn new_config() -> Self;
-    fn with_defaults(
-        entry: Option<String>,
-        output: Option<String>,
-        watch: Option<bool>,
-        repeat: Option<bool>,
-        debug: Option<bool>,
-        compress: Option<bool>,
-        sample_rate: Option<u32>,
-        audio_format: Option<String>,
-        output_format: Option<Vec<String>>,
-    ) -> Self;
-    fn get() -> Result<Self, String>
-    where
-        Self: Sized;
-    fn from_string(config_string: &str) -> Result<(Self, String), String>
-    where
-        Self: Sized;
-    fn write_config(&self, new_config: &Self) -> Result<(), String>
-    where
-        Self: Sized;
-}
-
-impl ProjectConfigExt for SharedProjectConfig {
-    fn new_config() -> Self {
-        SharedProjectConfig::default()
-    }
-
-    fn with_defaults(
-        entry: Option<String>,
-        output: Option<String>,
-        watch: Option<bool>,
-        repeat: Option<bool>,
-        debug: Option<bool>,
-        compress: Option<bool>,
-        sample_rate: Option<u32>,
-        audio_format: Option<String>,
-        output_format: Option<Vec<String>>,
-    ) -> Self {
-        SharedProjectConfig {
-            defaults: SharedProjectConfigDefaults {
-                entry,
-                output,
-                watch,
-                repeat,
-                debug,
-                compress,
-                sample_rate,
-                audio_format,
-                output_format,
-            },
-            banks: Some(Vec::new()),
-            plugins: Some(Vec::new()),
-        }
-    }
-
-    fn get() -> Result<Self, String> {
-        let config_path = path_utils::get_devalang_config_path()?;
-
-        let config_content = std::fs::read_to_string(&config_path)
-            .map_err(|e| format!("Failed to read config file: {}", e))?;
-
-        let config: SharedProjectConfig = toml::from_str(&config_content)
-            .map_err(|e| format!("Failed to parse config file: {}", e))?;
-
-        Ok(config)
-    }
-
-    fn from_string(config_string: &str) -> Result<(Self, String), String> {
-        let config: SharedProjectConfig = toml::from_str(config_string)
-            .map_err(|e| format!("Failed to parse config string: {}", e))?;
-        let config_path = ".devalang".to_string();
-
-        Ok((config, config_path))
-    }
-
-    fn write_config(&self, new_config: &Self) -> Result<(), String> {
-        let config_path: PathBuf = match path_utils::get_project_root() {
-            Ok(root) => root.join(path_utils::DEVALANG_CONFIG),
-            Err(_) => PathBuf::from(path_utils::DEVALANG_CONFIG),
-        };
-
-        let content = toml::to_string(new_config)
-            .map_err(|e| format!("Failed to serialize config: {}", e))?;
-
-        std::fs::write(&config_path, content).map_err(|e| {
-            format!(
-                "Failed to write config to file '{}': {}",
-                config_path.display(),
-                e
-            )
-        })?;
-
-        Ok(())
-    }
-}

package/rust/config/mod.rs

@@ -1,3 +0,0 @@
-pub mod driver;
-pub mod ops;
-pub mod settings;

package/rust/config/ops.rs

@@ -1,26 +0,0 @@
-use crate::config::driver::ProjectConfig;
-use std::fs;
-use std::path::Path;
-
-pub fn load_config(path: Option<&Path>) -> Option<ProjectConfig> {
-    let config_path_buf;
-    let config_path = match path {
-        Some(p) => p,
-        None => {
-            config_path_buf = match devalang_utils::path::get_devalang_config_path() {
-                Ok(p) => p,
-                Err(_) => {
-                    return None;
-                }
-            };
-            &config_path_buf
-        }
-    };
-
-    if config_path.exists() {
-        let content = fs::read_to_string(config_path).ok()?;
-        toml::from_str(&content).ok()
-    } else {
-        None
-    }
-}

package/rust/config/settings.rs

@@ -1,101 +0,0 @@
-use devalang_types::{TelemetrySettings, UserSettings};
-use serde_json::Value as JsonValue;
-use std::io::Write;
-
-pub fn get_home_dir() -> Option<std::path::PathBuf> {
-    dirs::home_dir()
-}
-
-pub fn get_devalang_homedir() -> std::path::PathBuf {
-    if let Some(home_dir) = get_home_dir() {
-        home_dir.join(".devalang")
-    } else {
-        std::path::PathBuf::from("~/.devalang")
-    }
-}
-
-pub fn get_default_user_config() -> UserSettings {
-    UserSettings {
-        session: "".into(),
-        telemetry: TelemetrySettings {
-            uuid: uuid::Uuid::new_v4().to_string(),
-            enabled: false,
-            level: "basic".into(),
-            stats: false,
-        },
-    }
-}
-
-pub fn get_user_config() -> Option<UserSettings> {
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        let file = std::fs::File::open(config_path).ok()?;
-        let settings = serde_json::from_reader(file).ok()?;
-        Some(settings)
-    } else {
-        None
-    }
-}
-
-pub fn write_user_config_file() {
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        let settings = get_user_config().unwrap_or_else(get_default_user_config);
-
-        let config_json = serde_json::to_string(&settings).unwrap();
-
-        if let Err(e) = write_config_atomic(&config_path, &config_json) {
-            println!("Could not write config file: {}", e);
-        }
-    } else {
-        println!("Could not create config file");
-    }
-}
-
-pub fn ensure_user_config_file_exists() {
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        if !config_path.exists() {
-            write_user_config_file();
-        }
-    }
-}
-
-pub fn set_user_config_value(key: &str, value: JsonValue) {
-    let mut settings = get_user_config().unwrap_or_default();
-
-    match (key, &value) {
-        ("telemetry", JsonValue::Bool(b)) => {
-            settings.telemetry.enabled = *b;
-        }
-        ("session", JsonValue::String(s)) => {
-            settings.session = s.clone();
-        }
-        _ => {
-            println!("Unsupported key or value type for '{}': {:?}", key, value);
-        }
-    }
-
-    if let Some(config_path) = get_devalang_homedir().join("config.json").into() {
-        let config_json = serde_json::to_string(&settings).unwrap();
-        if let Err(e) = write_config_atomic(&config_path, &config_json) {
-            println!("Could not write config file: {}", e);
-        }
-    } else {
-        println!("Could not create config file");
-    }
-}
-
-pub fn write_config_atomic(
-    config_path: &std::path::PathBuf,
-    contents: &str,
-) -> std::io::Result<()> {
-    if let Some(parent) = config_path.parent() {
-        std::fs::create_dir_all(parent)?;
-    }
-
-    let tmp_path = config_path.with_extension("json.tmp");
-    let mut tmp_file = std::fs::File::create(&tmp_path)?;
-    tmp_file.write_all(contents.as_bytes())?;
-    tmp_file.sync_all()?;
-    std::fs::rename(&tmp_path, config_path)?;
-
-    Ok(())
-}

package/rust/core/audio/engine/driver.rs

@@ -1,237 +0,0 @@
-use devalang_types::Value;
-use std::collections::HashMap;
-
-// Minimal representation of a MIDI note event for export purposes.
-#[derive(Debug, Clone, PartialEq)]
-pub struct MidiNoteEvent {
-    /// MIDI key number 0-127
-    pub key: u8,
-    /// velocity 0-127
-    pub vel: u8,
-    /// start time in milliseconds (absolute)
-    pub start_ms: u32,
-    /// duration in milliseconds
-    pub duration_ms: u32,
-    /// MIDI channel (0-15)
-    pub channel: u8,
-}
-
-// Sample rate and channel constants used throughout the engine.
-pub const SAMPLE_RATE: u32 = 44100;
-pub const CHANNELS: u16 = 2;
-
-/// AudioEngine holds the generated interleaved stereo buffer and
-/// provides simple utilities to mix/merge buffers and export WAV files.
-///
-/// Notes:
-/// - Buffer is interleaved stereo (L,R,L,R...).
-/// - Methods are synchronous and operate on in-memory buffers.
-///
-#[derive(Debug, Clone, PartialEq)]
-pub struct AudioEngine {
-    /// Master volume multiplier (not automatically applied by helpers).
-    pub volume: f32,
-    /// Interleaved i16 PCM buffer.
-    pub buffer: Vec<i16>,
-    /// Collected MIDI note events for export (non-audio representation).
-    pub midi_events: Vec<MidiNoteEvent>,
-    /// Map target synth -> last inserted note sample ranges (start_sample, total_samples)
-    pub last_notes: std::collections::HashMap<String, Vec<(usize, usize)>>,
-    /// Logical module name used for error traces/diagnostics.
-    pub module_name: String,
-    /// Simple diagnostic counter for inserted notes.
-    pub note_count: usize,
-    /// Sample rate (can be overridden per-engine)
-    pub sample_rate: u32,
-    /// Number of channels (interleaved). Defaults to 2.
-    pub channels: u16,
-}
-
-impl AudioEngine {
-    pub fn new(module_name: String) -> Self {
-        AudioEngine {
-            volume: 1.0,
-            buffer: vec![],
-            midi_events: Vec::new(),
-            module_name,
-            note_count: 0,
-            sample_rate: SAMPLE_RATE,
-            channels: CHANNELS,
-            last_notes: std::collections::HashMap::new(),
-        }
-    }
-
-    pub fn get_buffer(&self) -> &[i16] {
-        &self.buffer
-    }
-
-    pub fn get_normalized_buffer(&self) -> Vec<f32> {
-        self.buffer.iter().map(|&s| (s as f32) / 32768.0).collect()
-    }
-
-    pub fn mix(&mut self, other: &AudioEngine) {
-        let max_len = self.buffer.len().max(other.buffer.len());
-        self.buffer.resize(max_len, 0);
-
-        for (i, &sample) in other.buffer.iter().enumerate() {
-            self.buffer[i] = self.buffer[i].saturating_add(sample);
-        }
-    }
-
-    pub fn merge_with(&mut self, other: AudioEngine) {
-        // If the other buffer is empty, simply return without warning (common for spawns that produced nothing)
-        if other.buffer.is_empty() {
-            return;
-        }
-
-        // If the other buffer is present but contains only zeros, warn and skip merge
-        if other.buffer.iter().all(|&s| s == 0) {
-            eprintln!("⚠️ Skipping merge: other buffer is silent");
-            return;
-        }
-
-        if self.buffer.iter().all(|&s| s == 0) {
-            self.buffer = other.buffer;
-            return;
-        }
-
-        self.mix(&other);
-    }
-
-    pub fn set_duration(&mut self, duration_secs: f32) {
-        let total_samples =
-            (duration_secs * (self.sample_rate as f32) * (self.channels as f32)) as usize;
-
-        if self.buffer.len() < total_samples {
-            self.buffer.resize(total_samples, 0);
-        }
-    }
-
-    pub fn generate_midi_file(
-        &mut self,
-        output_path: &String,
-        bpm: Option<f32>,
-        tpqn: Option<u16>,
-    ) -> Result<(), String> {
-        crate::core::audio::engine::export::generate_midi_file_impl(
-            &self.midi_events,
-            output_path,
-            bpm,
-            tpqn,
-        )
-    }
-
-    pub fn generate_wav_file(
-        &mut self,
-        output_dir: &String,
-        audio_format: Option<String>,
-        sample_rate: Option<u32>,
-    ) -> Result<(), String> {
-        crate::core::audio::engine::export::generate_wav_file_impl(
-            &mut self.buffer,
-            output_dir,
-            audio_format,
-            sample_rate,
-        )
-    }
-
-    pub fn insert_note(
-        &mut self,
-        owner: Option<String>,
-        waveform: String,
-        freq: f32,
-        amp: f32,
-        start_time_ms: f32,
-        duration_ms: f32,
-        synth_params: HashMap<String, Value>,
-        note_params: HashMap<String, Value>,
-        automation: Option<HashMap<String, Value>>,
-    ) -> Vec<(usize, usize)> {
-        // Delegated implementation lives in notes.rs
-        crate::core::audio::engine::notes::insert_note_impl(
-            self,
-            owner,
-            waveform,
-            freq,
-            amp,
-            start_time_ms,
-            duration_ms,
-            synth_params,
-            note_params,
-            automation,
-        )
-    }
-
-    pub fn record_last_note_range(
-        &mut self,
-        owner: &str,
-        start_sample: usize,
-        total_samples: usize,
-    ) {
-        self.last_notes
-            .entry(owner.to_string())
-            .or_default()
-            .push((start_sample, total_samples));
-    }
-
-    // helper extraction functions left in this struct for now
-    pub(crate) fn extract_f32(&self, map: &HashMap<String, Value>, key: &str) -> Option<f32> {
-        match map.get(key) {
-            Some(Value::Number(n)) => Some(*n),
-            Some(Value::String(s)) => s.parse::<f32>().ok(),
-            Some(Value::Boolean(b)) => Some(if *b { 1.0 } else { 0.0 }),
-            _ => None,
-        }
-    }
-
-    pub(crate) fn extract_boolean(&self, map: &HashMap<String, Value>, key: &str) -> Option<bool> {
-        match map.get(key) {
-            Some(Value::Boolean(b)) => Some(*b),
-            Some(Value::Number(n)) => Some(*n != 0.0),
-            Some(Value::Identifier(s)) => {
-                if s == "true" {
-                    Some(true)
-                } else if s == "false" {
-                    Some(false)
-                } else {
-                    None
-                }
-            }
-            Some(Value::String(s)) => {
-                if s == "true" {
-                    Some(true)
-                } else if s == "false" {
-                    Some(false)
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        }
-    }
-}
-
-// Parse simple musical fraction strings like "1/16" into seconds using bpm
-pub fn parse_fraction_to_seconds(s: &str, bpm: f32) -> Option<f32> {
-    let trimmed = s.trim();
-    if let Some((num, den)) = trimmed.split_once('/') {
-        if let (Ok(n), Ok(d)) = (num.parse::<f32>(), den.parse::<f32>()) {
-            if d != 0.0 {
-                let beats = n / d; // e.g. 1/16 -> 0.0625 beats
-                let secs_per_beat = 60.0 / bpm.max(1.0);
-                return Some(beats * secs_per_beat);
-            }
-        }
-    }
-    None
-}
-
-// Convert a devalang_types::Duration to seconds using bpm when relevant.
-pub fn duration_to_seconds(d: &devalang_types::Duration, bpm: f32) -> Option<f32> {
-    use devalang_types::Duration as D;
-    match d {
-        D::Number(s) => Some(*s),
-        D::Beat(frac) | D::Identifier(frac) => parse_fraction_to_seconds(frac, bpm),
-        _ => None,
-    }
-}