@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/cli/bank/commands.rs

@@ -1,306 +0,0 @@
-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;
-
-pub async fn handle_update_bank_command(name: Option<String>) -> Result<(), String> {
-    let deva_dir = path_utils::ensure_deva_dir()?;
-    let bank_dir = deva_dir.join("banks");
-
-    if !bank_dir.exists() {
-        fs::create_dir_all(bank_dir.clone())
-            .map_err(|e| format!("Failed to create bank directory: {}", e))?;
-    }
-
-    if let Some(name) = name {
-        let bank_path = bank_dir.join(&name);
-        if !bank_path.exists() {
-            return Err(format!("Bank '{}' is not installed", name));
-        }
-
-        // Update specific bank
-        let latest_version = match crate::cli::bank::api::fetch_latest_version(name.clone()).await {
-            Ok(version) => version,
-            Err(err) => {
-                eprintln!("❌ Error fetching latest version for '{}': {}", name, err);
-                return Err(format!("Failed to fetch latest version for '{}'", name));
-            }
-        };
-
-        let local_bank_info_path = bank_path.join("bank.toml");
-        let local_version = match fs::read_to_string(&local_bank_info_path)
-            .ok()
-            .and_then(|content| toml::from_str::<BankFile>(&content).ok())
-            .map(|bf| bf.bank.version)
-        {
-            Some(version) => version,
-            None => {
-                eprintln!(
-                    "⚠️ Unable to read local version for '{}', forcing reinstall...",
-                    name
-                );
-                "".to_string() // Force update
-            }
-        };
-
-        if local_version != latest_version.version {
-            if let Err(e) = update_bank(&name, &latest_version.version).await {
-                eprintln!("❌ Error updating bank '{}': {}", name, e);
-            } else {
-                println!(
-                    "✅ Bank '{}' updated to version '{}'",
-                    name, latest_version.version
-                );
-            }
-        } else {
-            println!(
-                "Bank '{}' is already up-to-date (version {})",
-                name, latest_version.version
-            );
-
-            // Verify if the bank directory exists
-            if !bank_path.exists() {
-                eprintln!(
-                    "❌ Bank directory for '{}' does not exist, reinstalling...",
-                    name
-                );
-                if let Err(e) = install_bank(&name, &deva_dir).await {
-                    eprintln!("❌ Error reinstalling bank '{}': {}", name, e);
-                } else {
-                    println!("✅ Bank '{}' reinstalled successfully!", name);
-                }
-            }
-        }
-    } else {
-        // Update all banks
-        let config_path = path_utils::get_devalang_config_path()?;
-        let config = 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) = config_banks {
-            for bank in banks {
-                let bank_name = bank
-                    .path
-                    .strip_prefix("devalang://bank/")
-                    .unwrap_or(&bank.path)
-                    .to_string();
-
-                let latest_version =
-                    match crate::cli::bank::api::fetch_latest_version(bank_name.clone()).await {
-                        Ok(version) => version,
-                        Err(err) => {
-                            eprintln!(
-                                "❌ Error fetching latest version for '{}': {}",
-                                bank_name, err
-                            );
-                            continue;
-                        }
-                    };
-
-                if let Some(local_bank_version) = bank.version {
-                    if latest_version.version != local_bank_version {
-                        if let Err(e) = update_bank(&bank_name, &latest_version.version).await {
-                            eprintln!("❌ Error updating bank '{}': {}", bank_name, e);
-                        } else {
-                            println!(
-                                "✅ Bank '{}' updated to version '{}'",
-                                bank_name, latest_version.version
-                            );
-                        }
-                    } else {
-                        println!(
-                            "Bank '{}' is already up-to-date (version {})",
-                            bank_name, local_bank_version
-                        );
-
-                        // Verify if the bank directory exists
-                        let bank_path = bank_dir.join(&bank_name);
-
-                        if !bank_path.exists() {
-                            eprintln!(
-                                "❌ Bank directory for '{}' does not exist, reinstalling...",
-                                bank_name
-                            );
-                            if let Err(e) = install_bank(&bank_name, &deva_dir).await {
-                                eprintln!("❌ Error reinstalling bank '{}': {}", bank_name, e);
-                            } else {
-                                println!("✅ Bank '{}' reinstalled successfully!", bank_name);
-                            }
-                        }
-                    }
-                } else {
-                    // If the bank version is not specified in the config, install it
-                    if let Err(e) = install_bank(&bank_name, &deva_dir).await {
-                        eprintln!("❌ Error installing bank '{}': {}", bank_name, e);
-                    } else {
-                        println!("✅ Bank '{}' installed successfully!", bank_name);
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
-async fn update_bank(bank_name: &str, _latest_version: &str) -> Result<(), String> {
-    let deva_dir = path_utils::ensure_deva_dir()?;
-
-    // First, delete the existing bank directory
-    let bank_dir = deva_dir.join("banks").join(bank_name);
-
-    if bank_dir.exists() {
-        std::fs::remove_dir_all(&bank_dir).unwrap_or_else(|_| {
-            eprintln!(
-                "⚠️ Failed to remove old bank directory for '{}', aborting !",
-                bank_name
-            );
-            std::process::exit(1);
-        });
-    }
-
-    // Now, install the new version
-    if let Err(e) = install_bank(bank_name, &deva_dir).await {
-        eprintln!("❌ Error installing bank '{}': {}", bank_name, e);
-    } else {
-        println!("✅ Bank '{}' installed successfully!", bank_name);
-    }
-
-    let config_path = path_utils::get_devalang_config_path()?;
-    let _config = load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    // 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(())
-}
-
-pub async fn handle_remove_bank_command(name: String) -> Result<(), String> {
-    let deva_dir = path_utils::ensure_deva_dir()?;
-    let bank_dir = deva_dir.join("banks");
-
-    let bank_path = bank_dir.join(&name);
-
-    if !bank_path.exists() {
-        return Err(format!("Bank '{}' is not installed", name));
-    }
-
-    std::fs::remove_dir_all(&bank_path).map_err(|e| format!("Failed to remove bank: {}", e))?;
-
-    // Remove the bank from the config
-    let config_path = path_utils::get_devalang_config_path()?;
-    let _config = load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    // 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);
-
-    Ok(())
-}
-
-pub async fn handle_bank_available_command() -> Result<(), String> {
-    let bank_list = match crate::cli::bank::api::list_external_banks().await {
-        Ok(list) => list,
-        Err(_err) => {
-            eprintln!("❌ Error fetching bank list");
-            return Err("Failed to fetch bank list".into());
-        }
-    };
-
-    println!("Available banks for current project :");
-    println!(" ");
-
-    for bank in bank_list {
-        println!("📦 {}", bank.name);
-        println!("   - Version: {}", bank.version);
-        println!("   - Description: {}", bank.description);
-        println!("   - Author: {}", bank.author);
-        println!(" ");
-    }
-
-    Ok(())
-}
-
-pub async fn handle_bank_info_command(
-    name: String,
-) -> Result<BankInfo, Box<dyn std::error::Error>> {
-    crate::cli::bank::api::handle_bank_info_command(name).await
-}
-
-pub async fn handle_bank_list_command() -> Result<(), String> {
-    let bank_list = match crate::cli::bank::api::list_installed_banks().await {
-        Ok(list) => list,
-        Err(_err) => {
-            eprintln!("❌ Error fetching bank list");
-            return Err("Failed to fetch bank list".into());
-        }
-    };
-
-    println!("Installed banks for current project :");
-
-    for bank_toml in bank_list {
-        let latest_version =
-            match crate::cli::bank::api::fetch_latest_version(bank_toml.bank.name.clone()).await {
-                Ok(version) => version,
-                Err(_err) => {
-                    eprintln!(
-                        "❌ Error fetching latest version for '{}'",
-                        bank_toml.bank.name
-                    );
-                    continue;
-                }
-            };
-
-        let is_latest = if latest_version.version == bank_toml.bank.version {
-            "✅"
-        } else {
-            "❗"
-        };
-
-        println!(" ");
-        println!("📦 {}", bank_toml.bank.name);
-        println!(
-            "  - Version: v{} {} (latest: v{})",
-            bank_toml.bank.version, is_latest, latest_version.version
-        );
-        println!("  - Description: {}", bank_toml.bank.description);
-        println!("  - Author: {}", bank_toml.bank.author);
-    }
-
-    Ok(())
-}

package/rust/cli/bank/mod.rs

@@ -1,29 +0,0 @@
-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,153 +0,0 @@
-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")]
-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()
-            .and_then(|c| c.defaults.entry.clone())
-            .unwrap_or_default()
-    } else {
-        entry.clone().unwrap_or_default()
-    };
-
-    let fetched_output = if output.is_none() {
-        config
-            .as_ref()
-            .and_then(|c| c.defaults.output.clone())
-            .unwrap_or_default()
-    } else {
-        output.clone().unwrap_or_default()
-    };
-
-    let fetched_watch = if watch {
-        watch
-    } else {
-        config
-            .as_ref()
-            .and_then(|c| c.defaults.watch)
-            .unwrap_or(false)
-    };
-
-    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,
-            "Entry path is not specified. Please provide a valid entry path.",
-        );
-        return Err("missing entry path".to_string());
-    }
-    if fetched_output.is_empty() {
-        logger.log_message(
-            LogLevel::Error,
-            "Output directory is not specified. Please provide a valid output directory.",
-        );
-        return Err("missing output directory".to_string());
-    }
-
-    let entry_file = match find_entry_file(&fetched_entry) {
-        Some(p) => p,
-        None => {
-            logger.log_message(
-                LogLevel::Error,
-                &format!("❌ index.deva not found in directory: {}", fetched_entry),
-            );
-            return Err("index.deva not found".to_string());
-        }
-    };
-
-    // SECTION Begin build
-    if fetched_watch {
-        let _ = crate::cli::build::process::process_build(
-            entry_file.clone(),
-            fetched_output.clone(),
-            final_output_format.clone(),
-            final_audio_format,
-            sample_rate,
-            debug,
-            compress,
-        );
-
-        logger.log_message(
-            LogLevel::Watcher,
-            &format!("Watching for changes in '{}'...", fetched_entry),
-        );
-
-        watch_directory(entry_file.clone(), move || {
-            logger.log_message(LogLevel::Watcher, "Detected changes, re-building...");
-
-            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,
-            final_output_format,
-            final_audio_format,
-            sample_rate,
-            debug,
-            compress,
-        );
-        if let Err(e) = res {
-            return Err(e);
-        }
-    }
-
-    Ok(())
-}

package/rust/cli/build/mod.rs

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

package/rust/cli/build/process.rs

@@ -1,165 +0,0 @@
-use crate::core::{
-    builder::Builder,
-    debugger::{
-        lexer::write_lexer_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,
-};
-use devalang_utils::path::normalize_path;
-use devalang_utils::{
-    logger::{LogLevel, Logger},
-    spinner::start_spinner,
-};
-
-pub struct BuildStatsInput {
-    pub statements_by_module:
-        std::collections::HashMap<String, Vec<crate::core::parser::statement::Statement>>,
-    pub global_store: crate::core::store::global::GlobalStore,
-}
-
-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> {
-    let spinner = start_spinner("Building...");
-
-    let duration = std::time::Instant::now();
-
-    let normalized_entry_file = normalize_path(&entry);
-    let normalized_output_dir = normalize_path(&output);
-
-    let mut global_store = GlobalStore::new();
-    let module_loader = ModuleLoader::new(&normalized_entry_file, &normalized_output_dir);
-
-    // SECTION Load
-    // NOTE: We use modules in the build command, so we need to load them
-    let (modules_tokens, modules_statements) = module_loader.load_all_modules(&mut global_store);
-
-    // SECTION Write logs
-    if debug {
-        for (module_path, module) in global_store.modules.clone() {
-            write_module_variable_log_file(
-                &normalized_output_dir,
-                &module_path,
-                &module.variable_table,
-            );
-            write_module_function_log_file(
-                &normalized_output_dir,
-                &module_path,
-                &module.function_table,
-            );
-        }
-
-        write_lexer_log_file(
-            &normalized_output_dir,
-            "lexer_tokens.log",
-            modules_tokens.clone(),
-        );
-        write_preprocessor_log_file(
-            &normalized_output_dir,
-            "resolved_statements.log",
-            modules_statements.clone(),
-        );
-        write_variables_log_file(
-            &normalized_output_dir,
-            "global_variables.log",
-            global_store.variables.clone(),
-        );
-        write_function_log_file(
-            &normalized_output_dir,
-            "global_functions.log",
-            global_store.functions.clone(),
-        );
-    }
-
-    // SECTION Detect build-time errors prior to building
-    let all_errors = crate::core::error::collect_all_errors_with_modules(&modules_statements);
-    let (warnings, criticals) = crate::core::error::partition_errors(all_errors);
-    crate::core::error::log_errors_with_stack("Build", &warnings, &criticals);
-    if !criticals.is_empty() {
-        spinner.finish_and_clear();
-        return Err(format!(
-            "build failed with {} critical error(s): {}",
-            criticals.len(),
-            criticals[0].message
-        ));
-    }
-
-    // SECTION Building AST and Audio
-    let builder = Builder::new();
-    builder.build_ast(&modules_statements, &normalized_output_dir, compress);
-
-    // 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();
-
-    if debug {
-        let modules_loaded = global_store.modules.keys().collect::<Vec<_>>();
-        let global_variables_loaded = global_store.variables.variables.keys().collect::<Vec<_>>();
-        let global_functions_loaded = global_store.functions.functions.keys().collect::<Vec<_>>();
-
-        logger.log_message_with_trace(
-            LogLevel::Debug,
-            &format!("Modules loaded: {}", global_store.modules.len()),
-            modules_loaded.iter().map(|s| s.as_str()).collect(),
-        );
-        logger.log_message_with_trace(
-            LogLevel::Debug,
-            &format!(
-                "Global variables: {}",
-                global_store.variables.variables.len()
-            ),
-            global_variables_loaded.iter().map(|s| s.as_str()).collect(),
-        );
-        logger.log_message_with_trace(
-            LogLevel::Debug,
-            &format!(
-                "Global functions: {}",
-                global_store.functions.functions.len()
-            ),
-            global_functions_loaded.iter().map(|s| s.as_str()).collect(),
-        );
-    }
-
-    let success_message = format!(
-        "Build completed successfully in {:.2?}. Output files written to: '{}'",
-        duration.elapsed(),
-        normalized_output_dir
-    );
-
-    spinner.finish_and_clear();
-    logger.log_message(LogLevel::Success, &success_message);
-    Ok(BuildStatsInput {
-        statements_by_module: modules_statements,
-        global_store,
-    })
-}