@devaloop/devalang 0.0.1-alpha.16-hotfix.1 → 0.0.1-alpha.17

package/rust/cli/telemetry/event_creator.rs

@@ -0,0 +1,80 @@
+use crate::config::settings::get_user_config;
+use devalang_types::{
+    TelemetryErrorLevel as SharedTelemetryErrorLevel, TelemetryEvent as SharedTelemetryEvent,
+};
+
+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 mut default_event = TelemetryEvent::default();
+
+        if let Some(user_cfg) = get_user_config() {
+            default_event = TelemetryEvent {
+                uuid: user_cfg.telemetry.uuid.clone(),
+                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,
+            };
+        }
+
+        default_event
+    }
+}

package/rust/cli/telemetry/mod.rs

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

package/rust/cli/telemetry/send.rs

@@ -0,0 +1,51 @@
+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.rs → template/commands.rs}

@@ -1,4 +1,4 @@
-use crate::utils::file::format_file_size;
+use devalang_utils::file::format_file_size;
 use include_dir::{Dir, DirEntry, include_dir};
 
 static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");

package/rust/cli/template/mod.rs

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

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

@@ -1,6 +1,6 @@
-pub async fn handle_update_command(
-    _only: Option<String>,
-) -> Result<(), Box<dyn std::error::Error>> {
-    println!("Updates are not yet implemented. This is a placeholder function.");
-    Ok(())
-}
+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

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

package/rust/config/driver.rs

@@ -1,60 +1,45 @@
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
-#[derive(Debug, Deserialize, Clone, Serialize)]
-pub struct ProjectConfig {
-    pub defaults: ProjectConfigDefaults,
-    pub banks: Option<Vec<ProjectConfigBankEntry>>,
-    pub plugins: Option<Vec<PluginEntry>>,
-}
-
-#[derive(Debug, Deserialize, Clone, Serialize)]
-pub struct ProjectConfigDefaults {
-    pub entry: Option<String>,
-    pub output: Option<String>,
-    pub watch: Option<bool>,
-    pub repeat: Option<bool>,
-    pub debug: Option<bool>,
-    pub compress: Option<bool>,
-}
-
-#[derive(Debug, Deserialize, Clone, Serialize)]
-pub struct ProjectConfigBankMetadata {
-    pub bank: HashMap<String, String>,
-    pub triggers: Option<Vec<HashMap<String, String>>>,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-pub struct ProjectConfigBankEntry {
-    pub path: String,
-    pub version: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-pub struct PluginEntry {
-    pub path: String,
-    pub version: String,
-    pub author: String,
-    pub access: String,
+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>,
+    ) -> 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 ProjectConfig {
-    pub fn new() -> Self {
-        ProjectConfig {
-            defaults: ProjectConfigDefaults {
-                entry: None,
-                output: None,
-                watch: None,
-                repeat: None,
-                debug: None,
-                compress: None,
-            },
-            banks: Some(Vec::new()),
-            plugins: Some(Vec::new()),
-        }
+impl ProjectConfigExt for SharedProjectConfig {
+    fn new_config() -> Self {
+        SharedProjectConfig::default()
     }
 
-    pub fn with_defaults(
+    fn with_defaults(
         entry: Option<String>,
         output: Option<String>,
         watch: Option<bool>,
@@ -62,8 +47,8 @@ impl ProjectConfig {
         debug: Option<bool>,
         compress: Option<bool>,
     ) -> Self {
-        ProjectConfig {
-            defaults: ProjectConfigDefaults {
+        SharedProjectConfig {
+            defaults: SharedProjectConfigDefaults {
                 entry,
                 output,
                 watch,
@@ -76,42 +61,42 @@ impl ProjectConfig {
         }
     }
 
-    pub fn get() -> Result<ProjectConfig, String> {
-        let root = std::env::current_dir().unwrap();
-        let config_path = root.join(".devalang");
-
-        if config_path.try_exists().is_err() {
-            return Err(format!(
-                "Config file not found at path: {}",
-                config_path.display()
-            ));
-        }
+    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: ProjectConfig = toml::from_str(&config_content)
+        let config: SharedProjectConfig = toml::from_str(&config_content)
             .map_err(|e| format!("Failed to parse config file: {}", e))?;
 
         Ok(config)
     }
 
-    pub fn from_string(config_string: &str) -> Result<(Self, String), String> {
-        let config: ProjectConfig = toml::from_str(config_string)
+    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))
     }
 
-    pub fn write(&self, new_config: &ProjectConfig) -> Result<(), String> {
-        let config_path = ".devalang";
+    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, 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,4 +1,3 @@
 pub mod driver;
-pub mod loader;
+pub mod ops;
 pub mod settings;
-pub mod stats;

package/rust/config/ops.rs

@@ -0,0 +1,26 @@
+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,26 +1,17 @@
-use serde::{Deserialize, Serialize};
-use std::{any::Any, io::Write};
+use devalang_types::{TelemetrySettings, UserSettings};
+use serde_json::Value as JsonValue;
+use std::io::Write;
 
-#[derive(Serialize, Deserialize, Default, Debug)]
-pub struct UserSettings {
-    pub session: String,
-    pub telemetry: TelemetrySettings,
-}
-
-#[derive(Serialize, Deserialize, Default, Debug)]
-pub struct TelemetrySettings {
-    pub uuid: String,
-    pub stats: bool,
-    pub level: String,
-    pub enabled: bool,
-}
-
-pub fn get_home_dir() -> std::path::PathBuf {
-    dirs::home_dir().unwrap_or_default()
+pub fn get_home_dir() -> Option<std::path::PathBuf> {
+    dirs::home_dir()
 }
 
 pub fn get_devalang_homedir() -> std::path::PathBuf {
-    get_home_dir().join(".devalang")
+    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 {
@@ -28,16 +19,15 @@ pub fn get_default_user_config() -> UserSettings {
         session: "".into(),
         telemetry: TelemetrySettings {
             uuid: uuid::Uuid::new_v4().to_string(),
-            enabled: true,
+            enabled: false,
             level: "basic".into(),
-            stats: true,
+            stats: false,
         },
     }
 }
 
 pub fn get_user_config() -> Option<UserSettings> {
-    let config_path = get_devalang_homedir().join("config.json");
-    if config_path.try_exists().is_ok() {
+    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)
@@ -47,45 +37,65 @@ pub fn get_user_config() -> Option<UserSettings> {
 }
 
 pub fn write_user_config_file() {
-    let settings = get_user_config().unwrap_or(get_default_user_config());
+    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_path = get_devalang_homedir().join("config.json");
-    let mut file = std::fs::File::create(config_path).unwrap();
-    let config_json = serde_json::to_string(&settings).unwrap();
+        let config_json = serde_json::to_string(&settings).unwrap();
 
-    file.write_all(config_json.as_bytes()).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 set_user_config_bool(key: &str, value: bool) {
-    let mut settings = get_user_config().unwrap_or_default();
-
-    match key {
-        "telemetry" => {
-            settings.telemetry.enabled = value;
+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();
         }
-        _ => {}
     }
-
-    let config_path = get_devalang_homedir().join("config.json");
-    let config_json = serde_json::to_string(&settings).unwrap();
-    let mut file = std::fs::File::create(config_path).unwrap();
-
-    file.write_all(config_json.as_bytes()).unwrap();
 }
 
-pub fn set_user_config_string(key: &str, value: String) {
+pub fn set_user_config_value(key: &str, value: JsonValue) {
     let mut settings = get_user_config().unwrap_or_default();
 
-    match key {
-        "session" => {
-            settings.session = value;
+    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 config_path = get_devalang_homedir().join("config.json");
-    let config_json = serde_json::to_string(&settings).unwrap();
-    let mut file = std::fs::File::create(config_path).unwrap();
+    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)?;
 
-    file.write_all(config_json.as_bytes()).unwrap();
+    Ok(())
 }

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

@@ -0,0 +1,146 @@
+use devalang_types::Value;
+use std::collections::HashMap;
+
+type OptMap = Option<HashMap<String, Value>>;
+
+pub fn env_maps_from_automation(
+    automation: &Option<HashMap<String, Value>>,
+) -> (OptMap, OptMap, OptMap) {
+    if let Some(auto) = automation {
+        let vol = match auto.get("volume") {
+            Some(Value::Map(m)) => Some(m.clone()),
+            _ => None,
+        };
+        let pan = match auto.get("pan") {
+            Some(Value::Map(m)) => Some(m.clone()),
+            _ => None,
+        };
+        let pit = match auto.get("pitch") {
+            Some(Value::Map(m)) => Some(m.clone()),
+            _ => None,
+        };
+        (vol, pan, pit)
+    } else {
+        (None, None, None)
+    }
+}
+
+pub fn eval_env_map(
+    env_opt: &Option<HashMap<String, Value>>,
+    progress: f32,
+    default_val: f32,
+) -> f32 {
+    let env = match env_opt {
+        Some(m) => m,
+        None => {
+            return default_val;
+        }
+    };
+    let mut points: Vec<(f32, f32)> = Vec::with_capacity(env.len());
+    for (k, v) in env.iter() {
+        let key = if k.ends_with('%') {
+            &k[..k.len() - 1]
+        } else {
+            &k[..]
+        };
+        if let Ok(mut p) = key.parse::<f32>() {
+            p = (p / 100.0).clamp(0.0, 1.0);
+            let val = match v {
+                Value::Number(n) => *n,
+                Value::String(s) => s.parse::<f32>().unwrap_or(default_val),
+                Value::Identifier(s) => s.parse::<f32>().unwrap_or(default_val),
+                _ => default_val,
+            };
+            points.push((p, val));
+        }
+    }
+    if points.is_empty() {
+        return default_val;
+    }
+    points.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
+    let t = progress.clamp(0.0, 1.0);
+    if t <= points[0].0 {
+        return points[0].1;
+    }
+    if t >= points[points.len() - 1].0 {
+        return points[points.len() - 1].1;
+    }
+    for w in points.windows(2) {
+        let (p0, v0) = w[0];
+        let (p1, v1) = w[1];
+        if t >= p0 && t <= p1 {
+            let ratio = if (p1 - p0).abs() < f32::EPSILON {
+                0.0
+            } else {
+                (t - p0) / (p1 - p0)
+            };
+            return v0 + (v1 - v0) * ratio;
+        }
+    }
+    default_val
+}
+
+pub fn oscillator_sample(waveform: &str, current_freq: f32, t: f32) -> f32 {
+    let phase = 2.0 * std::f32::consts::PI * current_freq * t;
+    match waveform {
+        "sine" => phase.sin(),
+        "square" => {
+            if phase.sin() >= 0.0 {
+                1.0
+            } else {
+                -1.0
+            }
+        }
+        "saw" => 2.0 * (current_freq * t - (current_freq * t + 0.5).floor()),
+        "triangle" => (2.0 * (2.0 * (current_freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
+        _ => 0.0,
+    }
+}
+
+pub fn adsr_envelope_value(
+    i: usize,
+    attack_samples: usize,
+    decay_samples: usize,
+    sustain_samples: usize,
+    release_samples: usize,
+    sustain_level: f32,
+) -> f32 {
+    if i < attack_samples {
+        (i as f32) / (attack_samples as f32)
+    } else if i < attack_samples + decay_samples {
+        1.0 - (1.0 - sustain_level) * (((i - attack_samples) as f32) / (decay_samples as f32))
+    } else if i < attack_samples + decay_samples + sustain_samples {
+        sustain_level
+    } else if release_samples > 0 {
+        sustain_level
+            * (1.0
+                - ((i - attack_samples - decay_samples - sustain_samples) as f32)
+                    / (release_samples as f32))
+    } else {
+        0.0
+    }
+}
+
+pub fn pan_gains(pan_val: f32) -> (f32, f32) {
+    let left_gain = 1.0 - pan_val.max(0.0);
+    let right_gain = 1.0 + pan_val.min(0.0);
+    (left_gain, right_gain)
+}
+
+pub fn mix_stereo_samples_into_buffer(
+    engine: &mut super::synth::AudioEngine,
+    start_sample: usize,
+    channels: usize,
+    stereo_samples: &[i16],
+) {
+    let offset = start_sample * channels;
+    let required_len = offset + stereo_samples.len();
+
+    if engine.buffer.len() < required_len {
+        engine.buffer.resize(required_len, 0);
+    }
+
+    for (i, sample) in stereo_samples.iter().enumerate() {
+        engine.buffer[offset + i] = engine.buffer[offset + i].saturating_add(*sample);
+    }
+}

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

@@ -0,0 +1,7 @@
+pub mod helpers;
+pub mod sample;
+pub mod synth;
+
+pub use synth::AudioEngine;
+
+pub use helpers::*;