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

package/rust/cli/addon/list.rs

@@ -0,0 +1,224 @@
+use devalang_utils::logger::{LogLevel, Logger};
+
+#[derive(Clone)]
+struct InstalledAddon {
+    name: String,
+    addon_type: String,
+}
+
+pub async fn list_addons() -> Result<(), String> {
+    let deva_dir = devalang_utils::path::ensure_deva_dir()?;
+    let banks_dir = deva_dir.join("banks");
+    let plugins_dir = deva_dir.join("plugins");
+    let presets_dir = deva_dir.join("presets");
+    let templates_dir = deva_dir.join("templates");
+
+    let mut installed_addons = Vec::new();
+
+    if banks_dir.exists() {
+        if let Ok(entries) = std::fs::read_dir(&banks_dir) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_dir() {
+                        if let Some(name) = entry.file_name().to_str() {
+                            installed_addons.push(InstalledAddon {
+                                name: name.to_string(),
+                                addon_type: "bank".to_string(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if plugins_dir.exists() {
+        if let Ok(entries) = std::fs::read_dir(&plugins_dir) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_dir() {
+                        if let Some(name) = entry.file_name().to_str() {
+                            installed_addons.push(InstalledAddon {
+                                name: name.to_string(),
+                                addon_type: "plugin".to_string(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if presets_dir.exists() {
+        if let Ok(entries) = std::fs::read_dir(&presets_dir) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_dir() {
+                        if let Some(name) = entry.file_name().to_str() {
+                            installed_addons.push(InstalledAddon {
+                                name: name.to_string(),
+                                addon_type: "preset".to_string(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if templates_dir.exists() {
+        if let Ok(entries) = std::fs::read_dir(&templates_dir) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if file_type.is_dir() {
+                        if let Some(name) = entry.file_name().to_str() {
+                            installed_addons.push(InstalledAddon {
+                                name: name.to_string(),
+                                addon_type: "template".to_string(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let logger = Logger::new();
+
+    if installed_addons.is_empty() {
+        logger.log_message(LogLevel::Info, "No addon installed.");
+    } else {
+        let installed_banks = installed_addons.iter().filter(|a| a.addon_type == "bank");
+
+        let installed_plugins = installed_addons.iter().filter(|a| a.addon_type == "plugin");
+
+        let installed_presets = installed_addons.iter().filter(|a| a.addon_type == "preset");
+
+        let installed_templates = installed_addons
+            .iter()
+            .filter(|a| a.addon_type == "template");
+
+        if installed_banks.clone().count() > 0 {
+            let trace: Vec<String> = installed_addons
+                .iter()
+                .map(|a| format!("{}", a.name))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(LogLevel::Info, "Installed banks :", trace);
+        }
+
+        if installed_plugins.clone().count() > 0 {
+            let trace: Vec<String> = installed_addons
+                .iter()
+                .map(|a| format!("{}", a.name))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(LogLevel::Info, "Installed plugins :", trace);
+        }
+
+        if installed_presets.clone().count() > 0 {
+            let trace: Vec<String> = installed_addons
+                .iter()
+                .map(|a| format!("{}", a.name))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(LogLevel::Info, "Installed presets :", trace);
+        }
+
+        if installed_templates.clone().count() > 0 {
+            let trace: Vec<String> = installed_addons
+                .iter()
+                .map(|a| format!("{}", a.name))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(LogLevel::Info, "Installed templates :", trace);
+        }
+
+        if let Some(addon_not_in_config) = find_unused_addons(installed_addons.clone()) {
+            let trace: Vec<String> = addon_not_in_config
+                .iter()
+                .map(|a| format!("{} ({})", a.name, a.addon_type))
+                .collect();
+            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
+
+            logger.log_message_with_trace(
+                LogLevel::Warning,
+                "Some addons are installed but not referenced in the .devalang configuration file :",
+                trace,
+            );
+        }
+
+        logger.log_message(
+            LogLevel::Success,
+            format!("Found {} installed addon(s).", installed_addons.len()).as_str(),
+        );
+    }
+
+    Ok(())
+}
+
+fn find_unused_addons(addons: Vec<InstalledAddon>) -> Option<Vec<InstalledAddon>> {
+    let mut unused_addons = Vec::new();
+
+    let config_path = match devalang_utils::path::get_devalang_config_path() {
+        Ok(path) => path,
+        Err(_) => return None,
+    };
+
+    let config = match crate::config::ops::load_config(Some(&config_path)) {
+        Some(cfg) => cfg,
+        None => return None,
+    };
+
+    let mut referenced_addons = Vec::new();
+
+    if let Some(banks) = config.banks {
+        for bank in banks {
+            if let Some(name) = bank.path.strip_prefix("devalang://bank/") {
+                referenced_addons.push((name.to_string(), "bank".to_string()));
+            }
+        }
+    }
+
+    if let Some(plugins) = config.plugins {
+        for plugin in plugins {
+            if let Some(name) = plugin.path.strip_prefix("devalang://plugin/") {
+                referenced_addons.push((name.to_string(), "plugin".to_string()));
+            }
+        }
+    }
+
+    // TODO: Enable when presets and templates are supported in config
+    // if let Some(presets) = config.presets {
+    //     for preset in presets {
+    //         if let Some(name) = preset.path.strip_prefix("devalang://preset/") {
+    //             referenced_addons.push((name.to_string(), "preset".to_string()));
+    //         }
+    //     }
+    // }
+
+    // TODO: Enable when presets and templates are supported in config
+    // if let Some(templates) = config.templates {
+    //     for template in templates {
+    //         if let Some(name) = template.path.strip_prefix("devalang://template/") {
+    //             referenced_addons.push((name.to_string(), "template".to_string()));
+    //         }
+    //     }
+    // }
+
+    for addon in addons {
+        if !referenced_addons.contains(&(addon.name.clone(), addon.addon_type.clone())) {
+            unused_addons.push(addon);
+        }
+    }
+
+    if unused_addons.is_empty() {
+        None
+    } else {
+        Some(unused_addons)
+    }
+}

package/rust/cli/addon/metadata.rs

@@ -0,0 +1,124 @@
+use crate::web::api::get_api_url;
+
+#[derive(Debug, Clone)]
+pub struct AddonToDownloadMetadata {
+    pub name: String,
+    pub publisher: String,
+    pub addon_type: devalang_types::AddonType,
+}
+
+pub async fn get_addon_publisher_from_api(slug: &str) -> Result<String, String> {
+    let api_url = get_api_url();
+
+    let request_url = format!("{}/v1/products/getBySlug/{}", api_url, slug);
+
+    let client: reqwest::Client = reqwest::Client::builder()
+        .build()
+        .map_err(|_| "Failed to build HTTP client".to_string())?;
+
+    let resp = client
+        .get(&request_url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to receive response: {}", e))?;
+
+    let status = resp.status();
+    let body_text = resp
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response body: {}", e))?;
+
+    let json: serde_json::Value = match serde_json::from_str(&body_text) {
+        Ok(v) => v,
+        Err(_) => {
+            return Err(format!(
+                "Invalid JSON response (status {}): {}",
+                status, body_text
+            ));
+        }
+    };
+
+    let payload = json.get("payload");
+    let publisher = payload
+        .unwrap_or(&serde_json::Value::Null)
+        .get("publisher")
+        .and_then(|v| v.get("name"))
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown")
+        .to_string();
+
+    Ok(publisher)
+}
+
+pub async fn get_addon_from_api(slug: &str) -> Result<AddonToDownloadMetadata, String> {
+    let api_url = get_api_url();
+
+    let request_url = format!("{}/v1/products/getBySlug/{}", api_url, slug);
+
+    let client: reqwest::Client = reqwest::Client::builder()
+        .build()
+        .map_err(|_| "Failed to build HTTP client".to_string())?;
+
+    let resp = client
+        .get(&request_url)
+        .send()
+        .await
+        .map_err(|e| format!("Failed to receive response: {}", e))?;
+
+    let status = resp.status();
+    let body_text = resp
+        .text()
+        .await
+        .map_err(|e| format!("Failed to read response body: {}", e))?;
+
+    let json: serde_json::Value = match serde_json::from_str(&body_text) {
+        Ok(v) => v,
+        Err(_) => {
+            return Err(format!(
+                "Invalid JSON response (status {}): {}",
+                status, body_text
+            ));
+        }
+    };
+
+    let payload = json.get("payload");
+    let addon_type = payload
+        .unwrap_or(&serde_json::Value::Null)
+        .get("addon")
+        .unwrap_or(&serde_json::Value::Null)
+        .get("addon_type")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown");
+
+    let addon_type_enum = match addon_type {
+        "bank" => devalang_types::AddonType::Bank,
+        "plugin" => devalang_types::AddonType::Plugin,
+        "preset" => devalang_types::AddonType::Preset,
+        "template" => devalang_types::AddonType::Template,
+        _ => {
+            return Err(format!("Unknown addon type: {}", addon_type));
+        }
+    };
+
+    let addon_metadata = AddonToDownloadMetadata {
+        name: payload
+            .unwrap_or(&serde_json::Value::Null)
+            .get("addon")
+            .unwrap_or(&serde_json::Value::Null)
+            .get("name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("unknown")
+            .to_string(),
+        publisher: payload
+            .unwrap_or(&serde_json::Value::Null)
+            .get("publisher")
+            .unwrap_or(&serde_json::Value::Null)
+            .get("name")
+            .and_then(|v| v.as_str())
+            .unwrap_or("unknown")
+            .to_string(),
+        addon_type: addon_type_enum,
+    };
+
+    Ok(addon_metadata)
+}

package/rust/cli/addon/mod.rs

@@ -0,0 +1,8 @@
+pub mod commands;
+pub mod download;
+pub mod install;
+pub mod list;
+pub mod metadata;
+pub mod remove;
+pub mod update;
+pub mod utils;

package/rust/cli/addon/remove.rs

@@ -0,0 +1,271 @@
+use crate::config::ops::load_config;
+use devalang_core::config::driver::ProjectConfigExt;
+use devalang_utils::path as path_utils;
+use std::fs;
+
+pub async fn remove_addon(name: String) -> Result<(), String> {
+    let deva_dir = path_utils::ensure_deva_dir()?;
+
+    // Helper to extract publisher from a slug like 'publisher.name'
+    let extract_publisher = |s: &str| s.splitn(2, '.').next().unwrap_or("").to_string();
+
+    // Try to find in config first (banks/plugins)
+    if let Ok(config_path) = path_utils::get_devalang_config_path() {
+        if let Some(mut config) = load_config(Some(&config_path)) {
+            // BANKS
+            if let Some(banks) = config.banks.as_mut() {
+                if let Some(pos) = banks.iter().position(|b| {
+                    let slug = b.path.strip_prefix("devalang://bank/").unwrap_or(&b.path);
+                    // accept exact slug, exact path, or match by local name suffix (publisher/name or publisher.name)
+                    slug == name
+                        || b.path == name
+                        || slug.ends_with(&format!("/{}", name))
+                        || slug.ends_with(&format!(".{}", name))
+                }) {
+                    let entry = banks.remove(pos);
+                    let slug = entry
+                        .path
+                        .strip_prefix("devalang://bank/")
+                        .unwrap_or(&entry.path)
+                        .to_string();
+
+                    // parse publisher/name from slug (support 'publisher/name' or 'publisher.name')
+                    let (publisher, local_name) = if slug.contains('/') {
+                        let mut it = slug.splitn(2, '/');
+                        (
+                            it.next().unwrap().to_string(),
+                            it.next().unwrap().to_string(),
+                        )
+                    } else if slug.contains('.') {
+                        let mut it = slug.splitn(2, '.');
+                        (
+                            it.next().unwrap().to_string(),
+                            it.next().unwrap().to_string(),
+                        )
+                    } else {
+                        return Err(format!("Cannot parse bank slug '{}'", slug));
+                    };
+
+                    let local_path = deva_dir.join("banks").join(&publisher).join(&local_name);
+
+                    if !local_path.exists() {
+                        return Err(format!(
+                            "Local files for bank '{}' not found at '{}', aborting",
+                            slug,
+                            local_path.display()
+                        ));
+                    }
+
+                    fs::remove_dir_all(&local_path)
+                        .map_err(|e| format!("Failed to remove addon files: {}", e))?;
+
+                    if let Err(e) = config.write_config(&config) {
+                        eprintln!("Warning: failed to write updated config: {}", e);
+                    }
+
+                    println!("✅ Bank '{}' removed (publisher '{}')", slug, publisher);
+                    return Ok(());
+                }
+            }
+
+            // PLUGINS
+            if let Some(plugins) = config.plugins.as_mut() {
+                if let Some(pos) = plugins.iter().position(|p| {
+                    let slug = p.path.strip_prefix("devalang://plugin/").unwrap_or(&p.path);
+                    // accept exact slug, exact path, or match by local name suffix
+                    slug == name
+                        || p.path == name
+                        || slug.ends_with(&format!("/{}", name))
+                        || slug.ends_with(&format!(".{}", name))
+                }) {
+                    let entry = plugins.remove(pos);
+                    let slug = entry
+                        .path
+                        .strip_prefix("devalang://plugin/")
+                        .unwrap_or(&entry.path)
+                        .to_string();
+
+                    // parse publisher/name from slug (support 'publisher/name' or 'publisher.name')
+                    let (publisher, local_name) = if slug.contains('/') {
+                        let mut it = slug.splitn(2, '/');
+                        (
+                            it.next().unwrap().to_string(),
+                            it.next().unwrap().to_string(),
+                        )
+                    } else if slug.contains('.') {
+                        let mut it = slug.splitn(2, '.');
+                        (
+                            it.next().unwrap().to_string(),
+                            it.next().unwrap().to_string(),
+                        )
+                    } else {
+                        return Err(format!("Cannot parse plugin slug '{}'", slug));
+                    };
+
+                    let local_path = deva_dir.join("plugins").join(&publisher).join(&local_name);
+
+                    if !local_path.exists() {
+                        return Err(format!(
+                            "Local files for plugin '{}' not found at '{}', aborting",
+                            slug,
+                            local_path.display()
+                        ));
+                    }
+
+                    fs::remove_dir_all(&local_path)
+                        .map_err(|e| format!("Failed to remove addon files: {}", e))?;
+
+                    if let Err(e) = config.write_config(&config) {
+                        eprintln!("Warning: failed to write updated config: {}", e);
+                    }
+
+                    println!("✅ Plugin '{}' removed (publisher '{}')", slug, publisher);
+                    return Ok(());
+                }
+            }
+        }
+    }
+
+    // Not found in config: search filesystem under .deva and infer type
+    let dirs = ["banks", "plugins", "presets", "templates"];
+    for &d in &dirs {
+        let folder = deva_dir.join(d);
+        if !folder.exists() {
+            continue;
+        }
+
+        // If name looks like a slug (contains '.' or '/'), parse publisher and name and try candidate paths
+        if name.contains('.') || name.contains('/') {
+            let (publisher, local_name) = if name.contains('/') {
+                let mut it = name.splitn(2, '/');
+                (
+                    it.next().unwrap().to_string(),
+                    it.next().unwrap().to_string(),
+                )
+            } else {
+                let mut it = name.splitn(2, '.');
+                (
+                    it.next().unwrap().to_string(),
+                    it.next().unwrap().to_string(),
+                )
+            };
+
+            let candidate1 = folder.join(&publisher).join(&local_name);
+            let candidate2 = folder.join(format!("{}.{}", publisher, local_name));
+            let candidate3 = folder.join(&name);
+
+            let candidate = if candidate1.exists() {
+                candidate1
+            } else if candidate2.exists() {
+                candidate2
+            } else {
+                candidate3
+            };
+
+            if candidate.exists() {
+                fs::remove_dir_all(&candidate)
+                    .map_err(|e| format!("Failed to remove addon files: {}", e))?;
+
+                // also attempt to remove from config if possible
+                if let Ok(config_path) = path_utils::get_devalang_config_path() {
+                    if let Some(mut config) = load_config(Some(&config_path)) {
+                        match d {
+                            "banks" => {
+                                if let Some(banks) = config.banks.as_mut() {
+                                    let pattern1 =
+                                        format!("devalang://bank/{}/{}", publisher, local_name);
+                                    let pattern2 =
+                                        format!("devalang://bank/{}.{}", publisher, local_name);
+                                    banks.retain(|b| {
+                                        b.path != pattern1
+                                            && b.path != pattern2
+                                            && !b.path.ends_with(&local_name)
+                                    });
+                                }
+                            }
+                            "plugins" => {
+                                if let Some(plugins) = config.plugins.as_mut() {
+                                    let pattern1 =
+                                        format!("devalang://plugin/{}/{}", publisher, local_name);
+                                    let pattern2 =
+                                        format!("devalang://plugin/{}.{}", publisher, local_name);
+                                    plugins.retain(|p| {
+                                        p.path != pattern1
+                                            && p.path != pattern2
+                                            && !p.path.ends_with(&local_name)
+                                    });
+                                }
+                            }
+                            _ => {}
+                        }
+
+                        if let Err(e) = config.write_config(&config) {
+                            eprintln!("Warning: failed to write updated config: {}", e);
+                        }
+                    }
+                }
+
+                println!(
+                    "✅ Addon '{}/{}' removed from .deva/{} (publisher '{}')",
+                    publisher, local_name, d, publisher
+                );
+                return Ok(());
+            }
+        }
+
+        // Otherwise, scan directory entries: match exact name or suffix '.name'
+        if let Ok(entries) = fs::read_dir(&folder) {
+            for entry in entries.flatten() {
+                if let Ok(file_type) = entry.file_type() {
+                    if !file_type.is_dir() {
+                        continue;
+                    }
+                }
+                let file_name = entry.file_name();
+                let file_name = file_name.to_string_lossy();
+                if file_name == name || file_name.ends_with(&format!(".{}", name)) {
+                    let slug = file_name.to_string();
+                    let publisher = extract_publisher(&slug);
+                    let path = entry.path();
+                    fs::remove_dir_all(&path)
+                        .map_err(|e| format!("Failed to remove addon files: {}", e))?;
+
+                    // try to remove from config when banks/plugins
+                    if let Ok(config_path) = path_utils::get_devalang_config_path() {
+                        if let Some(mut config) = load_config(Some(&config_path)) {
+                            match d {
+                                "banks" => {
+                                    if let Some(banks) = config.banks.as_mut() {
+                                        banks.retain(|b| {
+                                            b.path != format!("devalang://bank/{}", slug)
+                                        });
+                                    }
+                                }
+                                "plugins" => {
+                                    if let Some(plugins) = config.plugins.as_mut() {
+                                        plugins.retain(|p| {
+                                            p.path != format!("devalang://plugin/{}", slug)
+                                        });
+                                    }
+                                }
+                                _ => {}
+                            }
+
+                            if let Err(e) = config.write_config(&config) {
+                                eprintln!("Warning: failed to write updated config: {}", e);
+                            }
+                        }
+                    }
+
+                    println!(
+                        "✅ Addon '{}' removed from .deva/{} (publisher '{}')",
+                        slug, d, publisher
+                    );
+                    return Ok(());
+                }
+            }
+        }
+    }
+
+    Err(format!("Addon '{}' not found", name))
+}