@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

package/rust/cli/bank/api.rs

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

package/rust/cli/bank/commands.rs

@@ -0,0 +1,275 @@
+use crate::cli::install::bank::install_bank;
+use crate::config::ops::load_config;
+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()))?;
+
+    // TODO Update the bank version in the config
+
+    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()))?;
+
+    // TODO Remove the bank from the config
+
+    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

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

package/rust/cli/build/commands.rs

@@ -0,0 +1,107 @@
+use crate::{config::driver::ProjectConfig, core::utils::path::find_entry_file};
+use devalang_utils::logger::{LogLevel, Logger};
+use devalang_utils::watcher::watch_directory;
+
+#[cfg(feature = "cli")]
+pub fn handle_build_command(
+    config: Option<ProjectConfig>,
+    entry: Option<String>,
+    output: Option<String>,
+    watch: bool,
+    debug: bool,
+    compress: bool,
+) -> Result<(), String> {
+    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();
+
+    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(),
+            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(),
+                debug,
+                compress,
+            );
+        })
+        .unwrap();
+    } else {
+        let res = crate::cli::build::process::process_build(
+            entry_file,
+            fetched_output,
+            debug,
+            compress,
+        );
+        if let Err(e) = res {
+            return Err(e);
+        }
+    }
+
+    Ok(())
+}

package/rust/cli/build/mod.rs

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

package/rust/cli/build/process.rs

@@ -0,0 +1,146 @@
+use crate::core::{
+    builder::Builder,
+    debugger::{
+        lexer::write_lexer_log_file,
+        module::{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::{
+    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,
+    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);
+    builder.build_audio(
+        &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,
+    })
+}