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

package/rust/cli/{check.rs → check/mod.rs}

@@ -11,13 +11,13 @@ use crate::{
         store::global::GlobalStore,
         utils::path::{find_entry_file, normalize_path},
     },
-    utils::{
-        logger::{LogLevel, Logger},
-        spinner::with_spinner,
-        watcher::watch_directory,
-    },
 };
-use std::{thread, time::Duration};
+
+use devalang_utils::{
+    logger::{LogLevel, Logger},
+    spinner::start_spinner,
+    watcher::watch_directory,
+};
 
 #[cfg(feature = "cli")]
 pub fn handle_check_command(
@@ -31,18 +31,18 @@ pub fn handle_check_command(
         config
             .as_ref()
             .and_then(|c| c.defaults.entry.clone())
-            .unwrap_or_else(|| "".to_string())
+            .unwrap_or_default()
     } else {
-        entry.clone().unwrap_or_else(|| "".to_string())
+        entry.clone().unwrap_or_default()
     };
 
     let fetched_output = if output.is_none() {
         config
             .as_ref()
             .and_then(|c| c.defaults.output.clone())
-            .unwrap_or_else(|| "".to_string())
+            .unwrap_or_default()
     } else {
-        output.clone().unwrap_or_else(|| "".to_string())
+        output.clone().unwrap_or_default()
     };
 
     let fetched_watch = if watch {
@@ -124,11 +124,9 @@ fn begin_check(
     entry: String,
     output: String,
     debug: bool,
-    config: Option<ProjectConfig>,
+    _config: Option<ProjectConfig>,
 ) -> Result<(), String> {
-    let spinner = with_spinner("Checking...", || {
-        thread::sleep(Duration::from_millis(800));
-    });
+    let spinner = start_spinner("Checking...");
 
     let duration = std::time::Instant::now();
 
@@ -145,7 +143,7 @@ fn begin_check(
     // Debugging: Log loaded modules and errors
     let logger = Logger::new();
     logger.log_message(LogLevel::Info, "Loaded modules:");
-    for (module_name, _) in &modules.0 {
+    for module_name in modules.0.keys() {
         logger.log_message(LogLevel::Info, &format!("- {}", module_name));
     }
 
@@ -185,10 +183,10 @@ fn begin_check(
         );
     }
 
-    let all_errors = crate::utils::error::collect_all_errors_with_modules(&modules.1);
+    let all_errors = crate::core::error::collect_all_errors_with_modules(&modules.1);
 
-    let (warnings, criticals) = crate::utils::error::partition_errors(all_errors);
-    crate::utils::error::log_errors_with_stack("Check", &warnings, &criticals);
+    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();
@@ -196,18 +194,6 @@ fn begin_check(
     } else {
         logger.log_message(LogLevel::Success, "No errors detected.");
 
-        // Compute and persist rich stats
-        let stats = crate::config::stats::compute_from(
-            &modules.1,
-            &global_store,
-            &config,
-            Some(&normalized_output_dir),
-        );
-        crate::config::stats::set_memory_stats(stats.clone());
-        if let Err(e) = crate::config::stats::save_to_file(&stats) {
-            eprintln!("[stats] failed to save: {}", e);
-        }
-
         let success_message = format!(
             "Check completed successfully in {:.2?}. Output files written to: '{}'",
             duration.elapsed(),
@@ -216,6 +202,7 @@ fn begin_check(
 
         spinner.finish_and_clear();
         logger.log_message(LogLevel::Success, &success_message);
-        Ok(())
     }
+
+    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(())
+}

package/rust/cli/discover/config.rs

@@ -0,0 +1,111 @@
+use devalang_core::config::driver::ProjectConfigExt;
+use devalang_types::{AddonWithMetadata, ProjectConfigBankEntry, ProjectConfigPluginEntry};
+use devalang_utils::path as path_utils;
+
+pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(), String> {
+    let config_path = path_utils::get_devalang_config_path()?;
+    let mut config = crate::config::ops::load_config(Some(&config_path))
+        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
+
+    for addon in addons {
+        let addon_path_as_devalang_protocol = format!(
+            "devalang://{}/{}.{}",
+            addon.addon_type, addon.metadata.author, addon.metadata.name
+        );
+
+        match addon.addon_type.as_str() {
+            "bank" => {
+                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 == addon_path_as_devalang_protocol);
+                if exists {
+                    println!("Bank '{}' already in config", addon.name);
+                    continue;
+                }
+
+                banks.push(ProjectConfigBankEntry {
+                    path: addon_path_as_devalang_protocol,
+                    version: Some(addon.metadata.version.clone()),
+                });
+            }
+
+            "plugin" => {
+                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 == addon_path_as_devalang_protocol);
+                if exists {
+                    println!("Plugin '{}' already in config", addon.name);
+                    continue;
+                }
+
+                plugins.push(ProjectConfigPluginEntry {
+                    path: addon_path_as_devalang_protocol,
+                    version: Some(addon.metadata.version.clone()),
+                });
+            }
+
+            // "preset" => {
+            //     if config.presets.is_none() {
+            //         config.presets = Some(Vec::new());
+            //     }
+
+            //     let presets = config.presets.as_mut().unwrap();
+
+            //     let exists = presets.iter().any(|p| p.path == addon_path_as_deva_protocol);
+            //     if exists {
+            //         println!("Preset '{}' already in config", addon.name);
+            //         continue;
+            //     }
+
+            //     presets.push(ProjectConfigPresetEntry {
+            //         path: addon_path_as_deva_protocol,
+            //         version: Some(addon.metadata.version.clone()),
+            //     });
+            // }
+
+            // "template" => {
+            //     if config.templates.is_none() {
+            //         config.templates = Some(Vec::new());
+            //     }
+
+            //     let templates = config.templates.as_mut().unwrap();
+
+            //     let exists = templates.iter().any(|t| t.path == addon_path_as_deva_protocol);
+            //     if exists {
+            //         println!("Template '{}' already in config", addon.name);
+            //         continue;
+            //     }
+
+            //     templates.push(ProjectConfigTemplateEntry {
+            //         path: addon_path_as_deva_protocol,
+            //         version: Some(addon.metadata.version.clone()),
+            //     });
+            // }
+            _ => {
+                println!(
+                    "Unknown addon type '{}' for addon '{}'",
+                    addon.addon_type, addon.name
+                );
+            }
+        }
+    }
+
+    // Update config with new addons
+    if let Err(e) = config.write_config(&config) {
+        return Err(format!("Failed to write config: {}", e));
+    }
+
+    Ok(())
+}

package/rust/cli/discover/fs.rs

@@ -0,0 +1,19 @@
+use std::{fs, io, path::Path};
+
+pub fn copy_dir_all(src: &Path, dst: &Path) -> Result<(), io::Error> {
+    if !dst.exists() {
+        fs::create_dir_all(dst)?;
+    }
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        let from = entry.path();
+        let to = dst.join(entry.file_name());
+        if ty.is_dir() {
+            copy_dir_all(&from, &to)?;
+        } else {
+            fs::copy(&from, &to)?;
+        }
+    }
+    Ok(())
+}

package/rust/cli/discover/install.rs

@@ -0,0 +1,103 @@
+use devalang_types::{AddonMetadata, AddonWithMetadata, DiscoveredAddon};
+use devalang_utils::path as path_utils;
+
+pub async fn install_selected_addons(
+    addons: Vec<DiscoveredAddon>,
+) -> Result<Vec<AddonWithMetadata>, String> {
+    let mut addons_enriched = Vec::new();
+
+    let tmp_dir = path_utils::ensure_deva_dir()?.join("tmp");
+
+    for addon in addons {
+        std::fs::create_dir_all(tmp_dir.join(&addon.name))
+            .map_err(|e| format!("Failed to create directory for addon {}: {}", addon.name, e))?;
+
+        let addon_path = tmp_dir.join(&addon.name);
+        devalang_utils::file::extract_zip_safely(&addon.path, &addon_path)
+            .map_err(|e| format!("Failed to extract addon {}: {}", addon.name, e))?;
+
+        let base = path_utils::ensure_deva_dir()?;
+        let target_addon_dir = match addon.addon_type.as_str() {
+            "bank" => base.join("banks"),
+            "plugin" => base.join("plugins"),
+            "preset" => base.join("presets"),
+            "template" => base.join("templates"),
+            _ => {
+                return Err(format!("Unknown addon type for addon {}", addon.name));
+            }
+        };
+
+        std::fs::create_dir_all(&target_addon_dir).map_err(|e| {
+            format!(
+                "Failed to create target directory for addon {}: {}",
+                addon.name, e
+            )
+        })?;
+
+        let target_addon_path_dir = target_addon_dir.join(&addon.name);
+        if target_addon_path_dir.exists() {
+            println!(
+                "Target addon directory {} already exists",
+                target_addon_path_dir.display()
+            );
+            continue;
+        }
+
+        if let Err(e) = std::fs::rename(&addon_path, &target_addon_path_dir) {
+            crate::cli::discover::fs::copy_dir_all(&addon_path, &target_addon_path_dir).map_err(
+                |err| {
+                    format!(
+                        "Failed to move addon {}: {} (rename error: {})",
+                        addon.name, err, e
+                    )
+                },
+            )?;
+            let _ = std::fs::remove_dir_all(&addon_path);
+        }
+
+        let addon_metadata_filename = match addon.addon_type.as_str() {
+            "bank" => "bank.toml",
+            "plugin" => "plugin.toml",
+            "preset" => "preset.toml",
+            "template" => "template.toml",
+            _ => {
+                return Err(format!("Unknown addon type for addon {}", addon.name));
+            }
+        };
+
+        let addon_metadata_path = target_addon_path_dir.join(addon_metadata_filename);
+        let addon_metadata_content = std::fs::read_to_string(&addon_metadata_path)
+            .map_err(|e| format!("Failed to read metadata for addon {}: {}", addon.name, e))?;
+
+        let parsed_meta = crate::cli::discover::metadata::parse_metadata_file(
+            &addon.addon_type,
+            &addon_metadata_content,
+        )
+        .unwrap_or(AddonMetadata {
+            name: addon.name.clone(),
+            author: "unknown".to_string(),
+            version: "".to_string(),
+            description: "".to_string(),
+            access: "".to_string(),
+        });
+
+        addons_enriched.push(AddonWithMetadata {
+            name: addon.name.clone(),
+            path: addon.path.clone().to_string_lossy().to_string(),
+            addon_type: addon.addon_type.clone(),
+            metadata: parsed_meta,
+        });
+
+        if let Err(e) = std::fs::remove_file(&addon.path) {
+            eprintln!(
+                "Failed to remove zipped file for addon {}: {}",
+                addon.name, e
+            );
+        }
+    }
+
+    // Best-effort cleanup of temporary extraction directory
+    let _ = std::fs::remove_dir_all(&tmp_dir);
+
+    Ok(addons_enriched)
+}

package/rust/cli/discover/metadata.rs

@@ -0,0 +1,48 @@
+use devalang_types::AddonMetadata;
+use toml::Value;
+
+pub fn parse_metadata_file(addon_type: &str, metadata_content: &str) -> Option<AddonMetadata> {
+    let parsed = metadata_content.parse::<Value>().ok()?;
+
+    let table = (match addon_type {
+        "bank" => parsed.get("bank"),
+        "plugin" => parsed.get("plugin"),
+        "preset" => parsed.get("preset"),
+        "template" => parsed.get("template"),
+        _ => None,
+    })?;
+
+    let name = table
+        .get("name")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let version = table
+        .get("version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let description = table
+        .get("description")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let author = table
+        .get("author")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+    let access = table
+        .get("access")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    Some(AddonMetadata {
+        name,
+        author,
+        version,
+        description,
+        access,
+    })
+}

package/rust/cli/discover/mod.rs

@@ -0,0 +1,5 @@
+pub mod commands;
+pub mod config;
+pub mod fs;
+pub mod install;
+pub mod metadata;