@devaloop/devalang 0.0.1-beta.3 → 0.1.1

package/rust/cli/discover/commands.rs

@@ -1,275 +0,0 @@
-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,
-};
-
-pub async fn handle_discover_command(no_clear_tmp: bool) -> Result<(), String> {
-    let deva_dir = path_utils::ensure_deva_dir()?;
-
-    // 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();
-
-    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_tar_gz(&p, out);
-                } else if p.is_file() {
-                    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_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();
-
-    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<_>>();
-
-    // 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(),
-    );
-    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());
-
-    if all_addons.is_empty() {
-        // No known types detected — include everything we discovered.
-        all_addons = addons_found.clone();
-    }
-
-    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, no_clear_tmp).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

@@ -1,109 +0,0 @@
-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.publisher, 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,
-                });
-            }
-
-            "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,
-                });
-            }
-
-            // "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

@@ -1,19 +0,0 @@
-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

@@ -1,214 +0,0 @@
-use devalang_types::{AddonMetadata, AddonWithMetadata, DiscoveredAddon};
-use devalang_utils::path as path_utils;
-
-pub async fn install_selected_addons(
-    addons: Vec<DiscoveredAddon>,
-    no_clear_tmp: bool,
-) -> 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))?;
-
-        // Read metadata from the extracted addon first so we can layout as <publisher>/<name>
-        // If the addon type is unknown (we found a .tar.gz), try to detect the
-        // metadata file inside the extracted folder to discover the real type.
-        let mut detected_addon_type = addon.addon_type.clone();
-        let mut parsed_meta_tmp = None;
-
-        if detected_addon_type == "unknown" {
-            // try detection by checking common metadata filenames
-            let candidates = ["bank.toml", "plugin.toml", "preset.toml", "template.toml"];
-            for candidate in &candidates {
-                let path = addon_path.join(candidate);
-                if path.exists() {
-                    detected_addon_type = match *candidate {
-                        "bank.toml" => "bank".to_string(),
-                        "plugin.toml" => "plugin".to_string(),
-                        "preset.toml" => "preset".to_string(),
-                        "template.toml" => "template".to_string(),
-                        _ => "unknown".to_string(),
-                    };
-                    if let Ok(content) = std::fs::read_to_string(&path) {
-                        parsed_meta_tmp = crate::cli::discover::metadata::parse_metadata_file(
-                            &detected_addon_type,
-                            &content,
-                        );
-                    }
-                    break;
-                }
-            }
-        } else {
-            let addon_metadata_filename = match addon.addon_type.as_str() {
-                "bank" => "bank.toml",
-                "plugin" => "plugin.toml",
-                "preset" => "preset.toml",
-                "template" => "template.toml",
-                _ => "",
-            };
-            if !addon_metadata_filename.is_empty() {
-                let addon_metadata_path_tmp = addon_path.join(addon_metadata_filename);
-                let addon_metadata_content_tmp =
-                    std::fs::read_to_string(&addon_metadata_path_tmp).ok();
-                if let Some(content) = addon_metadata_content_tmp {
-                    parsed_meta_tmp = crate::cli::discover::metadata::parse_metadata_file(
-                        &addon.addon_type,
-                        &content,
-                    );
-                }
-            }
-        }
-
-        let base = path_utils::ensure_deva_dir()?;
-        // Use detected_addon_type (may have been found from metadata)
-        // final_addon_type is what we will report and use for metadata lookup
-        let final_addon_type = if detected_addon_type == "unknown" {
-            addon.addon_type.clone()
-        } else {
-            detected_addon_type.clone()
-        };
-
-        let target_addon_dir = match final_addon_type.as_str() {
-            "bank" => base.join("banks"),
-            "plugin" => base.join("plugins"),
-            "preset" => base.join("presets"),
-            "template" => base.join("templates"),
-            _ => {
-                // Fallback: place unknown archives into plugins by default
-                base.join("plugins")
-            }
-        };
-
-        std::fs::create_dir_all(&target_addon_dir).map_err(|e| {
-            format!(
-                "Failed to create target directory for addon {}: {}",
-                addon.name, e
-            )
-        })?;
-
-        // prefer parsed metadata publisher/name, fall back to discovered publisher/name
-        let publisher_folder = parsed_meta_tmp
-            .as_ref()
-            .and_then(|m| {
-                if !m.publisher.is_empty() {
-                    Some(m.publisher.clone())
-                } else {
-                    None
-                }
-            })
-            .unwrap_or_else(|| addon.publisher.clone());
-
-        let name_folder = parsed_meta_tmp
-            .as_ref()
-            .and_then(|m| {
-                if !m.name.is_empty() {
-                    Some(m.name.clone())
-                } else {
-                    None
-                }
-            })
-            .unwrap_or_else(|| addon.name.clone());
-
-        let target_addon_path_dir = target_addon_dir.join(&publisher_folder).join(&name_folder);
-        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);
-        }
-        // Attempt to read final metadata file (use parsed_tmp as fallback)
-        let addon_metadata_filename = match final_addon_type.as_str() {
-            "bank" => "bank.toml",
-            "plugin" => "plugin.toml",
-            "preset" => "preset.toml",
-            "template" => "template.toml",
-            _ => "",
-        };
-
-        let parsed_meta = if addon_metadata_filename.is_empty() {
-            parsed_meta_tmp.unwrap_or(AddonMetadata {
-                name: "".to_string(),
-                publisher: "".to_string(),
-                version: "".to_string(),
-                description: "".to_string(),
-                access: "".to_string(),
-            })
-        } else {
-            let addon_metadata_path = target_addon_path_dir.join(addon_metadata_filename);
-            if let Ok(content) = std::fs::read_to_string(&addon_metadata_path) {
-                crate::cli::discover::metadata::parse_metadata_file(&final_addon_type, &content)
-                    .unwrap_or(parsed_meta_tmp.unwrap_or(AddonMetadata {
-                        name: "".to_string(),
-                        publisher: "".to_string(),
-                        version: "".to_string(),
-                        description: "".to_string(),
-                        access: "".to_string(),
-                    }))
-            } else {
-                parsed_meta_tmp.unwrap_or(AddonMetadata {
-                    name: "".to_string(),
-                    publisher: "".to_string(),
-                    version: "".to_string(),
-                    description: "".to_string(),
-                    access: "".to_string(),
-                })
-            }
-        };
-
-        // Record location as the final moved directory path
-        addons_enriched.push(AddonWithMetadata {
-            name: name_folder.clone(),
-            publisher: publisher_folder.clone(),
-            path: target_addon_path_dir.clone().to_string_lossy().to_string(),
-            addon_type: final_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: remove `.deva/tmp`
-    // only if it's empty after installing the selected addons and when the
-    // user did not pass --no-clear-tmp.
-    if !no_clear_tmp {
-        if tmp_dir.exists() {
-            match std::fs::read_dir(&tmp_dir) {
-                Ok(mut rd) => {
-                    if rd.next().is_none() {
-                        let _ = std::fs::remove_dir_all(&tmp_dir);
-                    }
-                }
-                Err(_) => {
-                    // ignore errors here - best-effort
-                }
-            }
-        }
-    }
-
-    Ok(addons_enriched)
-}

package/rust/cli/discover/metadata.rs

@@ -1,48 +0,0 @@
-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 publisher = table
-        .get("publisher")
-        .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,
-        publisher,
-        version,
-        description,
-        access,
-    })
-}

package/rust/cli/discover/mod.rs

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