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

package/rust/cli/check/mod.rs

@@ -1,208 +1,208 @@
-use crate::{
-    config::driver::ProjectConfig,
-    core::{
-        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::{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(())
-}
+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

@@ -1,57 +1,69 @@
 use crate::cli::discover::config::add_addons_to_config;
 use crate::cli::discover::install::install_selected_addons;
 use devalang_types::DiscoveredAddon;
+use devalang_utils::spinner::start_spinner;
 use devalang_utils::{
     logger::{LogLevel, Logger},
     path as path_utils,
-    spinner::start_spinner,
 };
 
-pub async fn handle_discover_command() -> Result<(), String> {
+pub async fn handle_discover_command(no_clear_tmp: bool) -> 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"];
+    // Search for compiled addon archives in the .deva directory
+    // New norm: archives are packaged as `.tar.gz`. We recursively find all
+    // files ending with `.tar.gz` and propose them for installation. The
+    // install flow will inspect the extracted content to determine the exact
+    // addon type (bank/plugin/preset/template) when possible.
 
     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>) {
+    fn walk_dir_collect_tar_gz(base: &std::path::Path, 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);
+                    walk_dir_collect_tar_gz(&p, 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(),
-                            });
-                        }
+                    let name = p.file_name().and_then(|s| s.to_str()).unwrap_or("");
+                    if name.ends_with(".tar.gz") || name.ends_with(".tgz") {
+                        // derive a friendly name (strip extensions)
+                        let stem = if name.ends_with(".tar.gz") {
+                            name.trim_end_matches(".tar.gz").to_string()
+                        } else {
+                            name.trim_end_matches(".tgz").to_string()
+                        };
+
+                        let publisher = p
+                            .parent()
+                            .and_then(|parent| parent.file_name())
+                            .and_then(|s| s.to_str())
+                            .unwrap_or("unknown")
+                            .to_string();
+
+                        out.push(DiscoveredAddon {
+                            name: stem,
+                            path: p.clone(),
+                            publisher: publisher.clone(),
+                            extension: "tar.gz".to_string(),
+                            addon_type: "unknown".to_string(),
+                        });
                     }
                 }
             }
         }
     }
 
-    walk_dir_collect(&deva_dir, &valid_addons_extensions, &mut addons_found);
+    walk_dir_collect_tar_gz(&deva_dir, &mut addons_found);
+
+    // Pre-classify discovered archives by inspecting their contents for metadata
+    for addon in addons_found.iter_mut() {
+        if let Ok(t) = devalang_utils::file::detect_addon_type_in_archive(&addon.path) {
+            if t != "unknown" {
+                addon.addon_type = t;
+            }
+        }
+    }
 
     let logger = Logger::new();
 
@@ -79,6 +91,10 @@ pub async fn handle_discover_command() -> Result<(), String> {
         .cloned()
         .collect::<Vec<_>>();
 
+    // Combine discovered known-type addons. If nothing was classified (all
+    // entries have `addon_type == "unknown"`), fall back to the raw
+    // `addons_found` so users can still install archives discovered in
+    // `.deva`.
     let mut all_addons = Vec::with_capacity(
         banks_found.len() + plugins_found.len() + presets_found.len() + templates_found.len(),
     );
@@ -87,6 +103,11 @@ pub async fn handle_discover_command() -> Result<(), String> {
     all_addons.extend(presets_found.iter().cloned());
     all_addons.extend(templates_found.iter().cloned());
 
+    if all_addons.is_empty() {
+        // No known types detected — include everything we discovered.
+        all_addons = addons_found.clone();
+    }
+
     println!();
 
     if all_addons.is_empty() {
@@ -220,7 +241,8 @@ pub async fn handle_discover_command() -> Result<(), String> {
         .cloned()
         .collect::<Vec<_>>();
 
-    let install_selected_addons_result = install_selected_addons(addons_to_install).await;
+    let install_selected_addons_result =
+        install_selected_addons(addons_to_install, no_clear_tmp).await;
     match install_selected_addons_result {
         Ok(addons_enriched) => {
             if let Err(e) = add_addons_to_config(addons_enriched).await {

package/rust/cli/discover/config.rs

@@ -9,8 +9,8 @@ pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(),
 
     for addon in addons {
         let addon_path_as_devalang_protocol = format!(
-            "devalang://{}/{}.{}",
-            addon.addon_type, addon.metadata.author, addon.metadata.name
+            "devalang://{}/{}/{}",
+            addon.addon_type, addon.metadata.publisher, addon.metadata.name
         );
 
         match addon.addon_type.as_str() {
@@ -31,7 +31,6 @@ pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(),
 
                 banks.push(ProjectConfigBankEntry {
                     path: addon_path_as_devalang_protocol,
-                    version: Some(addon.metadata.version.clone()),
                 });
             }
 
@@ -52,7 +51,6 @@ pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(),
 
                 plugins.push(ProjectConfigPluginEntry {
                     path: addon_path_as_devalang_protocol,
-                    version: Some(addon.metadata.version.clone()),
                 });
             }