@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.2

package/rust/cli/bank/api.rs

@@ -1,122 +1,122 @@
-use crate::web::cdn::get_cdn_url;
-use devalang_types::{BankFile, BankInfo};
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize)]
-pub struct BankList {
-    pub bank: Vec<BankInfo>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BankVersion {
-    pub version: String,
-}
-
-pub async fn handle_bank_info_command(
-    name: String,
-) -> Result<BankInfo, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/{}/info", cdn_url, name);
-
-    let response = reqwest::get(&url).await?;
-
-    if !response.status().is_success() {
-        return Err(format!("Failed to fetch bank info: HTTP {}", response.status()).into());
-    }
-
-    let bytes = response.bytes().await?;
-
-    let parsed: BankInfo = serde_json::from_slice(&bytes)?;
-
-    println!("📦 Bank Info for '{}':", name);
-    println!("  - Name: {}", parsed.name);
-    println!("  - Version: {}", parsed.version);
-    println!("  - Description: {}", parsed.description);
-    println!("  - Author: {}", parsed.author);
-
-    Ok(parsed)
-}
-
-pub async fn fetch_latest_version(
-    bank_name: String,
-) -> Result<BankVersion, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/{}/version", cdn_url, bank_name);
-
-    let response = reqwest::get(url).await?;
-
-    if !response.status().is_success() {
-        return Err(format!("❌ Failed to fetch version: HTTP {}", response.status()).into());
-    }
-
-    let bytes = response.bytes().await?;
-
-    let version: BankVersion = serde_json::from_slice(&bytes)?;
-
-    Ok(version)
-}
-
-pub async fn list_external_banks() -> Result<Vec<BankInfo>, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/list", cdn_url);
-
-    let response = reqwest::get(url).await?;
-
-    if !response.status().is_success() {
-        return Err(format!("❌ Failed to fetch bank list: HTTP {}", response.status()).into());
-    }
-
-    let bytes = response.bytes().await?;
-
-    let parsed: BankList = serde_json::from_slice(&bytes)?;
-
-    Ok(parsed.bank)
-}
-
-pub async fn list_installed_banks() -> Result<Vec<BankFile>, String> {
-    let deva_dir = devalang_utils::path::ensure_deva_dir()?;
-    let bank_dir = deva_dir.join("banks");
-
-    let mut banks = Vec::new();
-
-    if !bank_dir.exists() {
-        return Ok(banks); // No banks installed
-    }
-
-    let config_path = devalang_utils::path::get_devalang_config_path()?;
-    let config = crate::config::ops::load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    let config_banks = config.banks.clone();
-
-    if let Some(banks_in_toml) = config_banks {
-        for bank in banks_in_toml {
-            let bank_name = bank
-                .path
-                .strip_prefix("devalang://bank/")
-                .unwrap_or(&bank.path)
-                .to_string();
-
-            let bank_path = bank_dir.join(&bank_name);
-            if bank_path.exists() {
-                let bank_info_path = bank_path.join("bank.toml");
-
-                if bank_info_path.exists() {
-                    let content = std::fs::read_to_string(&bank_info_path)
-                        .map_err(|e| format!("Failed to read bank info: {}", e))?;
-
-                    match toml::from_str::<BankFile>(&content) {
-                        Ok(bank_info) => banks.push(bank_info),
-                        Err(_err) => {
-                            eprintln!("❌ Error parsing bank info for '{}'", bank_name);
-                        }
-                    }
-                } else {
-                    eprintln!("❌ Bank info file not found for '{}'", bank_name);
-                }
-            }
-        }
-    }
-
-    Ok(banks)
-}
+use crate::web::cdn::get_cdn_url;
+use devalang_types::{BankFile, BankInfo};
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct BankList {
+    pub bank: Vec<BankInfo>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BankVersion {
+    pub version: String,
+}
+
+pub async fn handle_bank_info_command(
+    name: String,
+) -> Result<BankInfo, Box<dyn std::error::Error>> {
+    let cdn_url = get_cdn_url();
+    let url = format!("{}/bank/{}/info", cdn_url, name);
+
+    let response = reqwest::get(&url).await?;
+
+    if !response.status().is_success() {
+        return Err(format!("Failed to fetch bank info: HTTP {}", response.status()).into());
+    }
+
+    let bytes = response.bytes().await?;
+
+    let parsed: BankInfo = serde_json::from_slice(&bytes)?;
+
+    println!("📦 Bank Info for '{}':", name);
+    println!("  - Name: {}", parsed.name);
+    println!("  - Version: {}", parsed.version);
+    println!("  - Description: {}", parsed.description);
+    println!("  - Author: {}", parsed.author);
+
+    Ok(parsed)
+}
+
+pub async fn fetch_latest_version(
+    bank_name: String,
+) -> Result<BankVersion, Box<dyn std::error::Error>> {
+    let cdn_url = get_cdn_url();
+    let url = format!("{}/bank/{}/version", cdn_url, bank_name);
+
+    let response = reqwest::get(url).await?;
+
+    if !response.status().is_success() {
+        return Err(format!("❌ Failed to fetch version: HTTP {}", response.status()).into());
+    }
+
+    let bytes = response.bytes().await?;
+
+    let version: BankVersion = serde_json::from_slice(&bytes)?;
+
+    Ok(version)
+}
+
+pub async fn list_external_banks() -> Result<Vec<BankInfo>, Box<dyn std::error::Error>> {
+    let cdn_url = get_cdn_url();
+    let url = format!("{}/bank/list", cdn_url);
+
+    let response = reqwest::get(url).await?;
+
+    if !response.status().is_success() {
+        return Err(format!("❌ Failed to fetch bank list: HTTP {}", response.status()).into());
+    }
+
+    let bytes = response.bytes().await?;
+
+    let parsed: BankList = serde_json::from_slice(&bytes)?;
+
+    Ok(parsed.bank)
+}
+
+pub async fn list_installed_banks() -> Result<Vec<BankFile>, String> {
+    let deva_dir = devalang_utils::path::ensure_deva_dir()?;
+    let bank_dir = deva_dir.join("banks");
+
+    let mut banks = Vec::new();
+
+    if !bank_dir.exists() {
+        return Ok(banks); // No banks installed
+    }
+
+    let config_path = devalang_utils::path::get_devalang_config_path()?;
+    let config = crate::config::ops::load_config(Some(&config_path))
+        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
+
+    let config_banks = config.banks.clone();
+
+    if let Some(banks_in_toml) = config_banks {
+        for bank in banks_in_toml {
+            let bank_name = bank
+                .path
+                .strip_prefix("devalang://bank/")
+                .unwrap_or(&bank.path)
+                .to_string();
+
+            let bank_path = bank_dir.join(&bank_name);
+            if bank_path.exists() {
+                let bank_info_path = bank_path.join("bank.toml");
+
+                if bank_info_path.exists() {
+                    let content = std::fs::read_to_string(&bank_info_path)
+                        .map_err(|e| format!("Failed to read bank info: {}", e))?;
+
+                    match toml::from_str::<BankFile>(&content) {
+                        Ok(bank_info) => banks.push(bank_info),
+                        Err(_err) => {
+                            eprintln!("❌ Error parsing bank info for '{}'", bank_name);
+                        }
+                    }
+                } else {
+                    eprintln!("❌ Bank info file not found for '{}'", bank_name);
+                }
+            }
+        }
+    }
+
+    Ok(banks)
+}

package/rust/cli/bank/commands.rs

@@ -1,5 +1,6 @@
 use crate::cli::install::bank::install_bank;
 use crate::config::ops::load_config;
+use devalang_core::config::driver::ProjectConfigExt;
 use devalang_types::{BankFile, BankInfo};
 use devalang_utils::path as path_utils;
 use std::fs;
@@ -173,7 +174,25 @@ async fn update_bank(bank_name: &str, _latest_version: &str) -> Result<(), Strin
     let _config = load_config(Some(&config_path))
         .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
 
-    // TODO Update the bank version in the config
+    // Update the bank version in the config
+    if let Some(mut config) = crate::config::ops::load_config(Some(&config_path)) {
+        if let Some(banks) = config.banks.as_mut() {
+            for bank in banks.iter_mut() {
+                if bank
+                    .path
+                    .strip_prefix("devalang://bank/")
+                    .unwrap_or(&bank.path)
+                    == bank_name
+                {
+                    bank.version = Some(_latest_version.to_string());
+                }
+            }
+
+            if let Err(e) = config.write_config(&config) {
+                eprintln!("Warning: failed to write updated config: {}", e);
+            }
+        }
+    }
 
     Ok(())
 }
@@ -195,7 +214,19 @@ pub async fn handle_remove_bank_command(name: String) -> Result<(), String> {
     let _config = load_config(Some(&config_path))
         .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
 
-    // TODO Remove the bank from the config
+    // Remove the bank from the config
+    if let Some(mut config) = crate::config::ops::load_config(Some(&config_path)) {
+        if let Some(banks) = config.banks.as_mut() {
+            banks.retain(|b| {
+                let name_in_path = b.path.strip_prefix("devalang://bank/").unwrap_or(&b.path);
+                name_in_path != name
+            });
+
+            if let Err(e) = config.write_config(&config) {
+                eprintln!("Warning: failed to write updated config: {}", e);
+            }
+        }
+    }
 
     println!("✅ Bank '{}' removed successfully", name);
 

package/rust/cli/bank/mod.rs

@@ -1,29 +1,29 @@
-use devalang_types::BankInfo;
-use serde::Deserialize;
-
-pub mod api;
-pub mod commands;
-
-#[derive(Debug, Deserialize)]
-pub struct BankList {
-    pub bank: Vec<BankInfo>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BankInfoFetched {
-    pub name: String,
-    pub version: String,
-    pub description: String,
-    pub author: String,
-    pub latest_version: String,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BankVersion {
-    pub version: String,
-}
-
-pub use commands::{
-    handle_bank_available_command, handle_bank_info_command, handle_bank_list_command,
-    handle_remove_bank_command, handle_update_bank_command,
-};
+use devalang_types::BankInfo;
+use serde::Deserialize;
+
+pub mod api;
+pub mod commands;
+
+#[derive(Debug, Deserialize)]
+pub struct BankList {
+    pub bank: Vec<BankInfo>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BankInfoFetched {
+    pub name: String,
+    pub version: String,
+    pub description: String,
+    pub author: String,
+    pub latest_version: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BankVersion {
+    pub version: String,
+}
+
+pub use commands::{
+    handle_bank_available_command, handle_bank_info_command, handle_bank_list_command,
+    handle_remove_bank_command, handle_update_bank_command,
+};

package/rust/cli/build/commands.rs

@@ -1,5 +1,6 @@
-use crate::{config::driver::ProjectConfig, core::utils::path::find_entry_file};
+use crate::config::driver::ProjectConfig;
 use devalang_utils::logger::{LogLevel, Logger};
+use devalang_utils::path::find_entry_file;
 use devalang_utils::watcher::watch_directory;
 
 #[cfg(feature = "cli")]
@@ -7,10 +8,14 @@ pub fn handle_build_command(
     config: Option<ProjectConfig>,
     entry: Option<String>,
     output: Option<String>,
+    output_format: Vec<crate::cli::parser::OutputFormat>,
+    audio_format: crate::cli::parser::AudioFormat,
+    sample_rate: u32,
     watch: bool,
     debug: bool,
     compress: bool,
 ) -> Result<(), String> {
+    // determine fetched values from config or CLI
     let fetched_entry = if entry.is_none() {
         config
             .as_ref()
@@ -40,6 +45,38 @@ pub fn handle_build_command(
 
     let logger = Logger::new();
 
+    // Determine final audio_format: prefer CLI, else config default if present
+    let mut final_audio_format = audio_format;
+    if let Some(cfg) = config.as_ref() {
+        if let Some(af) = cfg.defaults.audio_format.as_ref() {
+            // Only override if CLI provided an empty/placeholder — clap provides a default, so we only override when CLI wasn't explicit (rare).
+            // We'll accept values: "wav16", "wav24", "wav32" (case-insensitive)
+            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,
+            };
+        }
+    }
+
+    // Determine final output_format: prefer CLI vector, else config default list
+    let mut final_output_format: Vec<crate::cli::parser::OutputFormat> = output_format.clone();
+    if final_output_format.is_empty() {
+        if let Some(cfg) = config.as_ref() {
+            if let Some(ofs) = cfg.defaults.output_format.as_ref() {
+                for s in ofs {
+                    match s.to_lowercase().as_str() {
+                        "mid" | "midi" => {
+                            final_output_format.push(crate::cli::parser::OutputFormat::Mid);
+                        }
+                        _ => final_output_format.push(crate::cli::parser::OutputFormat::Wav),
+                    }
+                }
+            }
+        }
+    }
+
     if fetched_entry.is_empty() {
         logger.log_message(
             LogLevel::Error,
@@ -71,6 +108,9 @@ pub fn handle_build_command(
         let _ = crate::cli::build::process::process_build(
             entry_file.clone(),
             fetched_output.clone(),
+            final_output_format.clone(),
+            final_audio_format,
+            sample_rate,
             debug,
             compress,
         );
@@ -86,14 +126,24 @@ pub fn handle_build_command(
             let _ = crate::cli::build::process::process_build(
                 entry_file.clone(),
                 fetched_output.clone(),
+                final_output_format.clone(),
+                final_audio_format,
+                sample_rate,
                 debug,
                 compress,
             );
         })
         .unwrap();
     } else {
-        let res =
-            crate::cli::build::process::process_build(entry_file, fetched_output, debug, compress);
+        let res = crate::cli::build::process::process_build(
+            entry_file,
+            fetched_output,
+            final_output_format,
+            final_audio_format,
+            sample_rate,
+            debug,
+            compress,
+        );
         if let Err(e) = res {
             return Err(e);
         }

package/rust/cli/build/mod.rs

@@ -1,2 +1,2 @@
-pub mod commands;
-pub mod process;
+pub mod commands;
+pub mod process;

package/rust/cli/build/process.rs

@@ -2,14 +2,14 @@ use crate::core::{
     builder::Builder,
     debugger::{
         lexer::write_lexer_log_file,
-        module::{write_module_function_log_file, write_module_variable_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,
-    utils::path::normalize_path,
 };
+use devalang_utils::path::normalize_path;
 use devalang_utils::{
     logger::{LogLevel, Logger},
     spinner::start_spinner,
@@ -24,6 +24,9 @@ pub struct BuildStatsInput {
 pub fn process_build(
     entry: String,
     output: String,
+    output_format: Vec<crate::cli::parser::OutputFormat>,
+    audio_format: crate::cli::parser::AudioFormat,
+    sample_rate: u32,
     debug: bool,
     compress: bool,
 ) -> Result<BuildStatsInput, String> {
@@ -94,11 +97,27 @@ pub fn process_build(
     // SECTION Building AST and Audio
     let builder = Builder::new();
     builder.build_ast(&modules_statements, &normalized_output_dir, compress);
-    builder.build_audio(
-        &modules_statements,
-        &normalized_output_dir,
-        &mut global_store,
-    );
+
+    // generate audio output if requested
+    if output_format.contains(&crate::cli::parser::OutputFormat::Wav) {
+        let audio_format_str = format!("{:?}", audio_format);
+        builder.build_audio(
+            &modules_statements,
+            &normalized_output_dir,
+            &mut global_store,
+            Some(audio_format_str),
+            Some(sample_rate),
+        );
+    }
+
+    // generate midi output if requested
+    if output_format.contains(&crate::cli::parser::OutputFormat::Mid) {
+        builder.build_midi(
+            &modules_statements,
+            &normalized_output_dir,
+            &mut global_store,
+        );
+    }
 
     // SECTION Logging
     let logger = Logger::new();

package/rust/cli/check/mod.rs

@@ -3,15 +3,15 @@ use crate::{
     core::{
         debugger::{
             lexer::write_lexer_log_file,
-            module::{write_module_function_log_file, write_module_variable_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,
-        utils::path::{find_entry_file, normalize_path},
     },
 };
+use devalang_utils::path::{find_entry_file, normalize_path};
 
 use devalang_utils::{
     logger::{LogLevel, Logger},