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

package/rust/cli/telemetry.rs

@@ -1,19 +0,0 @@
-use crate::config::settings::set_user_config_bool;
-
-#[cfg(feature = "cli")]
-pub async fn handle_telemetry_enable_command() -> Result<(), String> {
-    set_user_config_bool("telemetry", true);
-
-    println!("Telemetry has been enabled.");
-
-    Ok(())
-}
-
-#[cfg(feature = "cli")]
-pub async fn handle_telemetry_disable_command() -> Result<(), String> {
-    set_user_config_bool("telemetry", false);
-
-    println!("Telemetry has been disabled.");
-
-    Ok(())
-}

package/rust/common/api.rs

@@ -1,5 +0,0 @@
-pub fn get_api_url() -> String {
-    let api_url = "https://api.devalang.com";
-    // let api_url = "http://127.0.0.1:8989";
-    api_url.to_string()
-}

package/rust/common/cdn.rs

@@ -1,5 +0,0 @@
-pub fn get_cdn_url() -> String {
-    let cdn_url = "https://cdn.devalang.com";
-    // let cdn_url = "http://127.0.0.1:8888";
-    cdn_url.to_string()
-}

package/rust/config/loader.rs

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

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