@devaloop/devalang 0.0.1-alpha.15 → 0.0.1-alpha.16-hotfix.0

package/rust/config/loader.rs

@@ -1,156 +1,165 @@
-use std::{ fs, path::Path };
-use crate::config::driver::{ BankEntry, BankMetadata, Config };
-
-pub fn load_config(path: Option<&Path>) -> Option<Config> {
-    let config_path = path.unwrap_or_else(|| Path::new(".devalang"));
-
-    if config_path.exists() {
-        let content = fs::read_to_string(config_path).ok()?;
-        toml::from_str(&content).ok()
-    } else {
-        None
-    }
-}
-
-pub fn update_bank_version_in_config(config: &mut Config, dependency: &str, new_version: &str) {
-    // Si le vecteur banks n'existe pas, on ne fait rien
-    if config.banks.is_none() {
-        println!("No banks configured.");
-        return;
-    }
-
-    let banks = config.banks.as_mut().unwrap();
-
-    if let Some(bank) = banks.iter_mut().find(|b| b.path.contains(dependency)) {
-        bank.version = Some(new_version.to_string());
-
-        if let Err(e) = config.write(config) {
-            eprintln!("❌ Failed to write config: {}", e);
-        } else {
-            println!("✅ Bank '{}' updated to version '{}'", dependency, new_version);
-        }
-    } else {
-        println!("Bank '{}' not found in config", dependency);
-    }
-}
-
-pub fn remove_bank_from_config(config: &mut Config, dependency: &str) {
-    if config.banks.is_none() {
-        println!("No banks configured.");
-        return;
-    }
-
-    let banks = config.banks.as_mut().unwrap();
-
-    if let Some(index) = banks.iter().position(|b| b.path.contains(dependency)) {
-        banks.remove(index);
-
-        if let Err(e) = config.write(config) {
-            eprintln!("❌ Failed to write config: {}", e);
-        } else {
-            println!("✅ Bank '{}' removed from config", dependency);
-        }
-    } else {
-        println!("Bank '{}' not found in config", dependency);
-    }
-}
-
-pub fn add_plugin_to_config(config: &mut Config, real_path: &Path, dependency: &str) {
-    if config.plugins.is_none() {
-        config.plugins = Some(Vec::new());
-    }
-
-    let plugins = config.plugins.as_mut().unwrap();
-
-    let exists = plugins.iter().any(|p| p.path == dependency);
-    if exists {
-        println!("Plugin '{}' already in config", dependency);
-        return;
-    }
-
-    let metadata_path = Path::new(real_path).join("plugin.toml");
-
-    if !metadata_path.exists() {
-        eprintln!("❌ Plugin metadata file '{}' does not exist", metadata_path.display());
-        return;
-    }
-
-    let metadata_content = std::fs
-        ::read_to_string(&metadata_path)
-        .expect("Failed to read plugin metadata file");
-
-    let metadata: std::collections::HashMap<String, String> = toml
-        ::from_str(&metadata_content)
-        .expect("Failed to parse plugin metadata file");
-
-    let plugin_entry = crate::config::driver::PluginEntry {
-        path: dependency.to_string(),
-        version: metadata
-            .get("version")
-            .cloned()
-            .unwrap_or_else(|| "0.0.1".to_string()),
-        author: metadata
-            .get("author")
-            .cloned()
-            .unwrap_or_else(|| "unknown".to_string()),
-        access: metadata
-            .get("access")
-            .cloned()
-            .unwrap_or_else(|| "public".to_string()),
-    };
-
-    plugins.push(plugin_entry);
-
-    if let Err(e) = config.write(config) {
-        eprintln!("❌ Failed to write config: {}", e);
-    } else {
-        println!("✅ Plugin '{}' added to config", dependency);
-    }
-}
-
-pub fn add_bank_to_config(config: &mut Config, real_path: &Path, dependency: &str) {
-    if config.banks.is_none() {
-        config.banks = Some(Vec::new());
-    }
-
-    let banks = config.banks.as_mut().unwrap();
-
-    let exists = banks.iter().any(|b| b.path == dependency);
-    if exists {
-        println!("Bank '{}' already in config", dependency);
-        return;
-    }
-
-    let metadata_path = Path::new(real_path).join("bank.toml");
-
-    if !metadata_path.exists() {
-        eprintln!("❌ Bank metadata file '{}' does not exist", metadata_path.display());
-        return;
-    }
-
-    let metadata_content = fs
-        ::read_to_string(&metadata_path)
-        .expect("Failed to read bank metadata file");
-
-    let metadata: BankMetadata = toml
-        ::from_str(&metadata_content)
-        .expect("Failed to parse bank metadata file");
-
-    let bank_to_insert = BankEntry {
-        path: dependency.to_string(),
-        version: Some(
-            metadata.bank
-                .get("version")
-                .cloned()
-                .unwrap_or_else(|| "0.0.1".to_string())
-        ),
-    };
-
-    banks.push(bank_to_insert);
-
-    if let Err(e) = config.write(config) {
-        eprintln!("❌ Failed to write config: {}", e);
-    } else {
-        println!("✅ Bank '{}' added to config", dependency);
-    }
-}
+use crate::config::driver::{ProjectConfig, ProjectConfigBankEntry, ProjectConfigBankMetadata};
+use std::{fs, path::Path};
+
+pub fn load_config(path: Option<&Path>) -> Option<ProjectConfig> {
+    let config_path = path.unwrap_or_else(|| Path::new(".devalang"));
+
+    if config_path.exists() {
+        let content = fs::read_to_string(config_path).ok()?;
+        toml::from_str(&content).ok()
+    } else {
+        None
+    }
+}
+
+pub fn update_bank_version_in_config(
+    config: &mut ProjectConfig,
+    dependency: &str,
+    new_version: &str,
+) {
+    if config.banks.is_none() {
+        println!("No banks configured.");
+        return;
+    }
+
+    let banks = config.banks.as_mut().unwrap();
+
+    if let Some(bank) = banks.iter_mut().find(|b| b.path.contains(dependency)) {
+        bank.version = Some(new_version.to_string());
+
+        if let Err(e) = config.write(config) {
+            eprintln!("❌ Failed to write config: {}", e);
+        } else {
+            println!(
+                "✅ Bank '{}' updated to version '{}'",
+                dependency, new_version
+            );
+        }
+    } else {
+        println!("Bank '{}' not found in config", dependency);
+    }
+}
+
+pub fn remove_bank_from_config(config: &mut ProjectConfig, dependency: &str) {
+    if config.banks.is_none() {
+        println!("No banks configured.");
+        return;
+    }
+
+    let banks = config.banks.as_mut().unwrap();
+
+    if let Some(index) = banks.iter().position(|b| b.path.contains(dependency)) {
+        banks.remove(index);
+
+        if let Err(e) = config.write(config) {
+            eprintln!("❌ Failed to write config: {}", e);
+        } else {
+            println!("✅ Bank '{}' removed from config", dependency);
+        }
+    } else {
+        println!("Bank '{}' not found in config", dependency);
+    }
+}
+
+pub fn add_plugin_to_config(config: &mut ProjectConfig, real_path: &Path, dependency: &str) {
+    if config.plugins.is_none() {
+        config.plugins = Some(Vec::new());
+    }
+
+    let plugins = config.plugins.as_mut().unwrap();
+
+    let exists = plugins.iter().any(|p| p.path == dependency);
+    if exists {
+        println!("Plugin '{}' already in config", dependency);
+        return;
+    }
+
+    let metadata_path = Path::new(real_path).join("plugin.toml");
+
+    if !metadata_path.exists() {
+        eprintln!(
+            "❌ Plugin metadata file '{}' does not exist",
+            metadata_path.display()
+        );
+        return;
+    }
+
+    let metadata_content =
+        std::fs::read_to_string(&metadata_path).expect("Failed to read plugin metadata file");
+
+    let metadata: std::collections::HashMap<String, String> =
+        toml::from_str(&metadata_content).expect("Failed to parse plugin metadata file");
+
+    let plugin_entry = crate::config::driver::PluginEntry {
+        path: dependency.to_string(),
+        version: metadata
+            .get("version")
+            .cloned()
+            .unwrap_or_else(|| "0.0.1".to_string()),
+        author: metadata
+            .get("author")
+            .cloned()
+            .unwrap_or_else(|| "unknown".to_string()),
+        access: metadata
+            .get("access")
+            .cloned()
+            .unwrap_or_else(|| "public".to_string()),
+    };
+
+    plugins.push(plugin_entry);
+
+    if let Err(e) = config.write(config) {
+        eprintln!("❌ Failed to write config: {}", e);
+    } else {
+        println!("✅ Plugin '{}' added to config", dependency);
+    }
+}
+
+pub fn add_bank_to_config(config: &mut ProjectConfig, real_path: &Path, dependency: &str) {
+    if config.banks.is_none() {
+        config.banks = Some(Vec::new());
+    }
+
+    let banks = config.banks.as_mut().unwrap();
+
+    let exists = banks.iter().any(|b| b.path == dependency);
+    if exists {
+        println!("Bank '{}' already in config", dependency);
+        return;
+    }
+
+    let metadata_path = Path::new(real_path).join("bank.toml");
+
+    if !metadata_path.exists() {
+        eprintln!(
+            "❌ Bank metadata file '{}' does not exist",
+            metadata_path.display()
+        );
+        return;
+    }
+
+    let metadata_content =
+        fs::read_to_string(&metadata_path).expect("Failed to read bank metadata file");
+
+    let metadata: ProjectConfigBankMetadata =
+        toml::from_str(&metadata_content).expect("Failed to parse bank metadata file");
+
+    let bank_to_insert = ProjectConfigBankEntry {
+        path: dependency.to_string(),
+        version: Some(
+            metadata
+                .bank
+                .get("version")
+                .cloned()
+                .unwrap_or_else(|| "0.0.1".to_string()),
+        ),
+    };
+
+    banks.push(bank_to_insert);
+
+    if let Err(e) = config.write(config) {
+        eprintln!("❌ Failed to write config: {}", e);
+    } else {
+        println!("✅ Bank '{}' added to config", dependency);
+    }
+}

package/rust/config/mod.rs

@@ -1,2 +1,4 @@
-pub mod loader;
-pub mod driver;
+pub mod driver;
+pub mod loader;
+pub mod settings;
+pub mod stats;

package/rust/config/settings.rs

@@ -0,0 +1,91 @@
+use serde::{Deserialize, Serialize};
+use std::{any::Any, 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_devalang_homedir() -> std::path::PathBuf {
+    get_home_dir().join(".devalang")
+}
+
+pub fn get_default_user_config() -> UserSettings {
+    UserSettings {
+        session: "".into(),
+        telemetry: TelemetrySettings {
+            uuid: uuid::Uuid::new_v4().to_string(),
+            enabled: true,
+            level: "basic".into(),
+            stats: true,
+        },
+    }
+}
+
+pub fn get_user_config() -> Option<UserSettings> {
+    let config_path = get_devalang_homedir().join("config.json");
+    if config_path.try_exists().is_ok() {
+        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() {
+    let settings = get_user_config().unwrap_or(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();
+
+    file.write_all(config_json.as_bytes()).unwrap();
+}
+
+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;
+        }
+        _ => {}
+    }
+
+    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) {
+    let mut settings = get_user_config().unwrap_or_default();
+
+    match key {
+        "session" => {
+            settings.session = value;
+        }
+        _ => {}
+    }
+
+    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();
+}

package/rust/config/stats.rs

@@ -0,0 +1,257 @@
+use super::settings::get_devalang_homedir;
+use crate::config::driver::ProjectConfig;
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    store::global::GlobalStore,
+};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::{
+    fs,
+    io::Write,
+    path::Path,
+    path::PathBuf,
+    sync::{Mutex, OnceLock},
+};
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct StatsCounts {
+    pub nb_files: usize,
+    pub nb_modules: usize,
+    pub nb_lines: usize,
+    pub nb_banks: usize,
+    pub nb_plugins: usize,
+}
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct StatsFeatures {
+    pub uses_imports: bool,
+    pub uses_functions: bool,
+    pub uses_groups: bool,
+    pub uses_automations: bool,
+    pub uses_loops: bool,
+}
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct StatsAudio {
+    pub avg_bpm: Option<u32>,
+    pub has_synths: bool,
+    pub has_samples: bool,
+}
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct ProjectStats {
+    pub counts: StatsCounts,
+    pub features: StatsFeatures,
+    pub audio: StatsAudio,
+}
+
+impl ProjectStats {
+    pub fn new() -> Self {
+        ProjectStats {
+            counts: StatsCounts {
+                nb_files: 0,
+                nb_modules: 0,
+                nb_lines: 0,
+                nb_banks: 0,
+                nb_plugins: 0,
+            },
+            features: StatsFeatures {
+                uses_imports: false,
+                uses_functions: false,
+                uses_groups: false,
+                uses_automations: false,
+                uses_loops: false,
+            },
+            audio: StatsAudio {
+                avg_bpm: None,
+                has_synths: false,
+                has_samples: false,
+            },
+        }
+    }
+
+    // Returns the in-memory stats if available, otherwise loads from file,
+    // otherwise returns a default struct.
+    pub fn get() -> Result<Self, String> {
+        if let Some(stats) = get_memory_stats() {
+            return Ok(stats);
+        }
+        if let Some(stats) = load_from_file() {
+            return Ok(stats);
+        }
+        Ok(Self::new())
+    }
+
+    // Saves stats to stats.json under the devalang home directory.
+    pub fn persist(&self) -> Result<(), String> {
+        save_to_file(self)
+    }
+}
+
+// ----------------------------
+// Storage helpers (memory/file)
+// ----------------------------
+
+static STATS_MEMORY: OnceLock<Mutex<ProjectStats>> = OnceLock::new();
+
+fn stats_file_path() -> PathBuf {
+    get_devalang_homedir().join("stats.json")
+}
+
+pub fn set_memory_stats(stats: ProjectStats) {
+    let m = STATS_MEMORY.get_or_init(|| Mutex::new(ProjectStats::new()));
+    if let Ok(mut guard) = m.lock() {
+        *guard = stats;
+    }
+}
+
+pub fn get_memory_stats() -> Option<ProjectStats> {
+    let m = STATS_MEMORY.get_or_init(|| Mutex::new(ProjectStats::new()));
+    if let Ok(guard) = m.lock() {
+        // If it's the default value (all zero/false/None), still return it; caller can decide.
+        return Some(guard.clone());
+    }
+    None
+}
+
+pub fn load_from_file() -> Option<ProjectStats> {
+    let path = stats_file_path();
+    if !path.exists() {
+        return None;
+    }
+    match fs::read_to_string(&path) {
+        Ok(content) => match serde_json::from_str::<ProjectStats>(&content) {
+            Ok(stats) => Some(stats),
+            Err(_) => None,
+        },
+        Err(_) => None,
+    }
+}
+
+pub fn save_to_file(stats: &ProjectStats) -> Result<(), String> {
+    let path = stats_file_path();
+    let dir = path
+        .parent()
+        .unwrap_or(&get_devalang_homedir())
+        .to_path_buf();
+    if !dir.exists() {
+        fs::create_dir_all(&dir).map_err(|e| format!("failed to create stats dir: {}", e))?;
+    }
+    let json = serde_json::to_string_pretty(stats)
+        .map_err(|e| format!("failed to serialize stats: {}", e))?;
+    let mut file =
+        fs::File::create(&path).map_err(|e| format!("failed to create stats file: {}", e))?;
+    file.write_all(json.as_bytes())
+        .map_err(|e| format!("failed to write stats file: {}", e))?;
+    Ok(())
+}
+
+// Compute stats from modules and store
+pub fn compute_from(
+    statements_by_module: &HashMap<String, Vec<Statement>>,
+    global_store: &GlobalStore,
+    config: &Option<ProjectConfig>,
+    _output_dir: Option<&str>,
+) -> ProjectStats {
+    let mut stats = ProjectStats::new();
+
+    // Counts
+    stats.counts.nb_modules = statements_by_module.len();
+    stats.counts.nb_files = stats.counts.nb_modules; // number of source files loaded
+
+    let mut total_lines = 0usize;
+    for (path, _stmts) in statements_by_module.iter() {
+        let p = Path::new(path);
+        if let Ok(content) = fs::read_to_string(p) {
+            total_lines += content.lines().count();
+        }
+    }
+    stats.counts.nb_lines = total_lines;
+
+    // Banks/Plugins from config
+    if let Some(cfg) = config {
+        stats.counts.nb_banks = cfg.banks.as_ref().map(|v| v.len()).unwrap_or(0);
+        stats.counts.nb_plugins = cfg.plugins.as_ref().map(|v| v.len()).unwrap_or(0);
+    }
+
+    // Features and audio
+    let mut bpm_sum: f32 = 0.0;
+    let mut bpm_count: usize = 0;
+
+    fn visit(
+        stmts: &[Statement],
+        acc: &mut ProjectStats,
+        bpm_sum: &mut f32,
+        bpm_count: &mut usize,
+    ) {
+        for s in stmts {
+            match &s.kind {
+                StatementKind::Import { .. } => acc.features.uses_imports = true,
+                StatementKind::Function { body, .. } => {
+                    acc.features.uses_functions = true;
+                    visit(body, acc, bpm_sum, bpm_count);
+                }
+                StatementKind::Group => {
+                    acc.features.uses_groups = true;
+                    if let Some(body) = extract_body_block(&s.value) {
+                        visit(body, acc, bpm_sum, bpm_count);
+                    }
+                }
+                StatementKind::Automate { .. } => acc.features.uses_automations = true,
+                StatementKind::Loop => {
+                    acc.features.uses_loops = true;
+                    if let Some(body) = extract_body_block(&s.value) {
+                        visit(body, acc, bpm_sum, bpm_count);
+                    }
+                }
+                StatementKind::Synth => acc.audio.has_synths = true,
+                StatementKind::Tempo => {
+                    if let crate::core::shared::value::Value::Number(bpm) = &s.value {
+                        *bpm_sum += *bpm as f32;
+                        *bpm_count += 1;
+                    }
+                }
+                StatementKind::Trigger { entity, .. } => {
+                    let e = entity.to_lowercase();
+                    if e.ends_with(".wav") || e.ends_with(".mp3") || e.contains("devalang://bank/")
+                    {
+                        acc.audio.has_samples = true;
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    fn extract_body_block(v: &crate::core::shared::value::Value) -> Option<&[Statement]> {
+        use crate::core::shared::value::Value;
+        if let Value::Map(map) = v {
+            if let Some(Value::Block(stmts)) = map.get("body") {
+                return Some(stmts.as_slice());
+            }
+        }
+        None
+    }
+
+    for (_path, stmts) in statements_by_module.iter() {
+        visit(stmts, &mut stats, &mut bpm_sum, &mut bpm_count);
+    }
+
+    if !stats.audio.has_samples {
+        for (_k, v) in global_store.variables.variables.iter() {
+            if let crate::core::shared::value::Value::String(s) = v {
+                if s.starts_with("devalang://bank/") {
+                    stats.audio.has_samples = true;
+                    break;
+                }
+            }
+        }
+    }
+
+    if bpm_count > 0 {
+        stats.audio.avg_bpm = Some((bpm_sum / bpm_count as f32).round() as u32);
+    }
+
+    stats
+}