@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

package/rust/cli/build/process.rs

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

package/rust/cli/check/mod.rs

@@ -0,0 +1,208 @@
+use crate::{
+    config::driver::ProjectConfig,
+    core::{
+        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::{find_entry_file, normalize_path};
+
+use devalang_utils::{
+    logger::{LogLevel, Logger},
+    spinner::start_spinner,
+    watcher::watch_directory,
+};
+
+#[cfg(feature = "cli")]
+pub fn handle_check_command(
+    config: Option<ProjectConfig>,
+    entry: Option<String>,
+    output: Option<String>,
+    watch: bool,
+    debug: 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 check
+    if fetched_watch {
+        let _ = begin_check(
+            entry_file.clone(),
+            fetched_output.clone(),
+            debug,
+            config.clone(),
+        );
+
+        logger.log_message(
+            LogLevel::Watcher,
+            &format!("Watching for changes in '{}'...", fetched_entry),
+        );
+
+        let cfg_for_watch = config.clone();
+        watch_directory(entry_file.clone(), move || {
+            logger.log_message(LogLevel::Watcher, "Detected changes, re-checking...");
+            if let Err(e) = begin_check(
+                entry_file.clone(),
+                fetched_output.clone(),
+                debug,
+                cfg_for_watch.clone(),
+            ) {
+                eprintln!("[check] failed: {}", e);
+            }
+        })
+        .unwrap();
+    } else {
+        begin_check(
+            entry_file.clone(),
+            fetched_output.clone(),
+            debug,
+            config.clone(),
+        )?;
+    }
+    Ok(())
+}
+
+fn begin_check(
+    entry: String,
+    output: String,
+    debug: bool,
+    _config: Option<ProjectConfig>,
+) -> Result<(), String> {
+    let spinner = start_spinner("Checking...");
+
+    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 don't use modules in the check command, but we still need to load them
+    let modules = module_loader.load_all_modules(&mut global_store);
+
+    // Debugging: Log loaded modules and errors
+    let logger = Logger::new();
+    logger.log_message(LogLevel::Info, "Loaded modules:");
+    for module_name in modules.0.keys() {
+        logger.log_message(LogLevel::Info, &format!("- {}", module_name));
+    }
+
+    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.0.clone(),
+        );
+        write_preprocessor_log_file(
+            &normalized_output_dir,
+            "resolved_statements.log",
+            modules.1.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(),
+        );
+    }
+
+    let all_errors = crate::core::error::collect_all_errors_with_modules(&modules.1);
+
+    let (warnings, criticals) = crate::core::error::partition_errors(all_errors);
+    crate::core::error::log_errors_with_stack("Check", &warnings, &criticals);
+
+    if !criticals.is_empty() {
+        spinner.finish_and_clear();
+        return Err("check failed with critical errors".to_string());
+    } else {
+        logger.log_message(LogLevel::Success, "No errors detected.");
+
+        let success_message = format!(
+            "Check 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(())
+}

package/rust/cli/discover/commands.rs

@@ -0,0 +1,253 @@
+use crate::cli::discover::config::add_addons_to_config;
+use crate::cli::discover::install::install_selected_addons;
+use devalang_types::DiscoveredAddon;
+use devalang_utils::{
+    logger::{LogLevel, Logger},
+    path as path_utils,
+    spinner::start_spinner,
+};
+
+pub async fn handle_discover_command() -> Result<(), String> {
+    let deva_dir = path_utils::ensure_deva_dir()?;
+
+    // Search for addons (banks, plugins, presets, templates) in the .deva directory
+    let valid_addons_extensions = ["devabank", "devaplugin", "devapreset", "devatemplate"];
+
+    let mut addons_found = Vec::new();
+
+    // Recursively walk the .deva directory and collect addon files matching
+    // the known addon extensions. This allows discovery in nested folders.
+    fn walk_dir_collect(base: &std::path::Path, exts: &[&str], out: &mut Vec<DiscoveredAddon>) {
+        if let Ok(entries) = std::fs::read_dir(base) {
+            for entry in entries.filter_map(|e| e.ok()) {
+                let p = entry.path();
+                if p.is_dir() {
+                    walk_dir_collect(&p, exts, out);
+                } else if p.is_file() {
+                    if let Some(ext) = p.extension().and_then(|s| s.to_str()) {
+                        if exts.contains(&ext) {
+                            let name = p
+                                .file_stem()
+                                .map(|s| s.to_string_lossy().to_string())
+                                .unwrap_or_default();
+                            let addon_type = match ext {
+                                "devabank" => "bank",
+                                "devaplugin" => "plugin",
+                                "devapreset" => "preset",
+                                "devatemplate" => "template",
+                                _ => "unknown",
+                            };
+
+                            out.push(DiscoveredAddon {
+                                path: p.clone(),
+                                name,
+                                extension: ext.to_string(),
+                                addon_type: addon_type.to_string(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    walk_dir_collect(&deva_dir, &valid_addons_extensions, &mut addons_found);
+
+    let logger = Logger::new();
+
+    let banks_found = addons_found
+        .iter()
+        .filter(|addon| addon.addon_type == "bank")
+        .cloned()
+        .collect::<Vec<_>>();
+
+    let plugins_found = addons_found
+        .iter()
+        .filter(|addon| addon.addon_type == "plugin")
+        .cloned()
+        .collect::<Vec<_>>();
+
+    let presets_found = addons_found
+        .iter()
+        .filter(|addon| addon.addon_type == "preset")
+        .cloned()
+        .collect::<Vec<_>>();
+
+    let templates_found = addons_found
+        .iter()
+        .filter(|addon| addon.addon_type == "template")
+        .cloned()
+        .collect::<Vec<_>>();
+
+    let mut all_addons = Vec::with_capacity(
+        banks_found.len() + plugins_found.len() + presets_found.len() + templates_found.len(),
+    );
+    all_addons.extend(banks_found.iter().cloned());
+    all_addons.extend(plugins_found.iter().cloned());
+    all_addons.extend(presets_found.iter().cloned());
+    all_addons.extend(templates_found.iter().cloned());
+
+    println!();
+
+    if all_addons.is_empty() {
+        logger.log_message(LogLevel::Error, "No addons found in the '.deva' folder");
+        return Ok(());
+    }
+
+    if !banks_found.is_empty() {
+        let mut bank_traces: Vec<String> = Vec::new();
+
+        for addon in &banks_found {
+            bank_traces.push(addon.name.to_string());
+        }
+
+        let trace_refs: Vec<&str> = bank_traces.iter().map(|s| s.as_str()).collect();
+
+        logger.log_message_with_trace(
+            LogLevel::Info,
+            format!("Found {} compiled banks in workspace", banks_found.len()).as_str(),
+            trace_refs,
+        );
+    }
+
+    if !plugins_found.is_empty() {
+        let mut plugin_traces: Vec<String> = Vec::new();
+
+        for addon in &plugins_found {
+            plugin_traces.push(addon.name.to_string());
+        }
+
+        let trace_refs: Vec<&str> = plugin_traces.iter().map(|s| s.as_str()).collect();
+
+        logger.log_message_with_trace(
+            LogLevel::Info,
+            format!(
+                "Found {} compiled plugins in workspace",
+                plugins_found.len()
+            )
+            .as_str(),
+            trace_refs,
+        );
+    }
+
+    if !presets_found.is_empty() {
+        let mut preset_traces: Vec<String> = Vec::new();
+
+        for addon in &presets_found {
+            preset_traces.push(addon.name.to_string());
+        }
+
+        let trace_refs: Vec<&str> = preset_traces.iter().map(|s| s.as_str()).collect();
+
+        logger.log_message_with_trace(
+            LogLevel::Info,
+            format!(
+                "Found {} compiled presets in workspace",
+                presets_found.len()
+            )
+            .as_str(),
+            trace_refs,
+        );
+    }
+
+    if !templates_found.is_empty() {
+        let mut template_traces: Vec<String> = Vec::new();
+
+        for addon in &templates_found {
+            template_traces.push(addon.name.to_string());
+        }
+
+        let trace_refs: Vec<&str> = template_traces.iter().map(|s| s.as_str()).collect();
+
+        logger.log_message_with_trace(
+            LogLevel::Info,
+            format!(
+                "Found {} compiled templates in workspace",
+                templates_found.len()
+            )
+            .as_str(),
+            trace_refs,
+        );
+    }
+
+    println!();
+
+    // Build user-friendly, unique labels tied to each addon by including the path
+    let choice_labels: Vec<String> = all_addons
+        .iter()
+        .map(|addon| {
+            format!(
+                "{}: {} ({})",
+                addon.addon_type,
+                addon.name,
+                addon.path.display()
+            )
+        })
+        .collect();
+
+    let selected_addons = match inquire::MultiSelect::new(
+        "Select addons to install:",
+        choice_labels.clone(),
+    )
+    .prompt()
+    {
+        Ok(selected_addons) => selected_addons,
+        Err(err) => {
+            logger.log_message(
+                LogLevel::Error,
+                format!("Error selecting addons: {}", err).as_str(),
+            );
+
+            return Err(format!("Error selecting addons: {}", err));
+        }
+    };
+
+    let spinner = start_spinner("Installing addons...");
+
+    let addons_to_install = selected_addons
+        .iter()
+        .filter_map(|label| {
+            all_addons.iter().find(|addon| {
+                let candidate = format!(
+                    "{}: {} ({})",
+                    addon.addon_type,
+                    addon.name,
+                    addon.path.display()
+                );
+                &candidate == label
+            })
+        })
+        .cloned()
+        .collect::<Vec<_>>();
+
+    let install_selected_addons_result = install_selected_addons(addons_to_install).await;
+    match install_selected_addons_result {
+        Ok(addons_enriched) => {
+            if let Err(e) = add_addons_to_config(addons_enriched).await {
+                spinner.finish_and_clear();
+                logger.log_message(
+                    LogLevel::Error,
+                    format!("Failed to add addons to config: {}", e).as_str(),
+                );
+                return Err(format!("Failed to add addons to config: {}", e));
+            }
+
+            spinner.finish_and_clear();
+            println!();
+            logger.log_message(
+                LogLevel::Success,
+                "Successfully installed addons !".to_string().as_str(),
+            );
+        }
+        Err(e) => {
+            spinner.finish_and_clear();
+            logger.log_message(
+                LogLevel::Error,
+                format!("Failed to install addons: {}", e).as_str(),
+            );
+            return Err(format!("Failed to install addons: {}", e));
+        }
+    }
+
+    Ok(())
+}