@devaloop/devalang 0.0.1-alpha.13 → 0.0.1-alpha.15

package/rust/installer/plugin.rs

@@ -0,0 +1,55 @@
+use std::path::{ Path, PathBuf };
+use crate::{
+    common::cdn::get_cdn_url,
+    config::loader::{ add_plugin_to_config, load_config },
+    installer::utils::{ download_file, extract_archive },
+};
+
+pub async fn install_plugin(name: &str, target_dir: &Path) -> Result<(), String> {
+    let cdn_url = get_cdn_url();
+    let url = format!("{}/plugin/{}/download", cdn_url, name);
+
+    let plugin_dir = target_dir.join("plugin");
+    let archive_path = PathBuf::from(format!("./.deva/tmp/{}.devaplugin", name));
+    let extract_path = plugin_dir.join(name);
+
+    if extract_path.exists() {
+        println!(
+            "Plugin '{}' already exists at '{}'. Skipping install.",
+            name,
+            extract_path.display()
+        );
+        return Ok(());
+    }
+
+    download_file(&url, &archive_path).await.map_err(|e| format!("Failed to download: {}", e))?;
+
+    extract_archive(&archive_path, &extract_path).await.map_err(|e|
+        format!("Failed to extract: {}", e)
+    )?;
+
+    // Add the plugin to the config
+    let root_dir = target_dir
+        .parent()
+        .ok_or_else(|| "Failed to determine root directory".to_string())?;
+
+    let config_path = root_dir.join(".devalang");
+    if !config_path.exists() {
+        return Err(
+            format!(
+                "Config file not found at '{}'. Please run 'devalang init' before adding an addon",
+                config_path.display()
+            )
+        );
+    }
+
+    let mut config = load_config(Some(&config_path)).ok_or_else(||
+        format!("Failed to load config from '{}'", config_path.display())
+    )?;
+
+    let dependency_path = &format!("devalang://plugin/{}", name);
+
+    add_plugin_to_config(&mut config, &extract_path, dependency_path);
+
+    Ok(())
+}

package/rust/main.rs

@@ -15,18 +15,21 @@ use crate::{
             handle_bank_available_command,
             handle_bank_info_command,
             handle_bank_list_command,
-            handle_remove_bank_command, handle_update_bank_command,
+            handle_remove_bank_command,
+            handle_update_bank_command,
         },
         build::handle_build_command,
         check::handle_check_command,
         driver::{ BankCommand, Cli, Commands, InstallCommand, TemplateCommand },
         init::handle_init_command,
-        install::handle_install_bank_command,
+        install::handle_install_command,
+        login::handle_login_command,
         play::handle_play_command,
         template::{ handle_template_info_command, handle_template_list_command },
         update::handle_update_command,
     },
     config::{ driver::Config, loader::load_config },
+    installer::addon::AddonType,
 };
 
 #[tokio::main]
@@ -55,25 +58,35 @@ async fn main() -> io::Result<()> {
                 }
             }
 
-        Commands::Check { entry, output, watch, compilation_mode, debug } => {
-            handle_check_command(config, entry, output, watch);
+        Commands::Check { entry, output, watch, debug } => {
+            handle_check_command(config, entry, output, watch, debug);
         }
 
-        Commands::Build { entry, output, watch, compilation_mode, debug, compress } => {
-            handle_build_command(config, entry, output, watch);
+        Commands::Build { entry, output, watch, debug, compress } => {
+            handle_build_command(config, entry, output, watch, debug, compress);
         }
 
-        Commands::Play { entry, output, watch, repeat } => {
-            handle_play_command(config, entry, output, watch, repeat);
+        Commands::Play { entry, output, watch, repeat, debug } => {
+            handle_play_command(config, entry, output, watch, repeat, debug);
         }
 
         Commands::Install { command } =>
             match command {
                 InstallCommand::Bank { name } => {
-                    if let Err(err) = handle_install_bank_command(name).await {
+                    if let Err(err) = handle_install_command(name, AddonType::Bank).await {
                         eprintln!("❌ Failed to install bank: {}", err);
                     }
                 }
+                InstallCommand::Plugin { name } => {
+                    if let Err(err) = handle_install_command(name, AddonType::Plugin).await {
+                        eprintln!("❌ Failed to install plugin: {}", err);
+                    }
+                }
+                InstallCommand::Preset { name } => {
+                    if let Err(err) = handle_install_command(name, AddonType::Preset).await {
+                        eprintln!("❌ Failed to install preset: {}", err);
+                    }
+                }
             }
 
         Commands::Bank { command } =>
@@ -115,7 +128,16 @@ async fn main() -> io::Result<()> {
             }
         }
 
-        _ => {}
+        Commands::Login { .. } => {
+            if let Err(err) = handle_login_command().await {
+                eprintln!("❌ Login failed: {}", err);
+            }
+        }
+
+        Commands::Logout { .. } => {
+            eprintln!("❌ Logout command is not implemented yet.");
+        }
+
     }
 
     Ok(())

package/rust/utils/error.rs

@@ -0,0 +1,51 @@
+use crate::core::{
+    error::ErrorResult,
+    parser::statement::{Statement, StatementKind},
+    shared::value::Value,
+};
+
+/// Recursively collects errors from a list of statements.
+///
+/// This function traverses the provided statements and aggregates any
+/// `Unknown` or explicit `Error` statements into a flat vector.
+/// It also descends into loop bodies to ensure nested errors are
+/// surfaced.
+pub fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    errors.extend(collect_errors_recursively(body_statements));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}

package/rust/utils/logger.rs

@@ -7,6 +7,7 @@ pub enum LogLevel {
     Success,
     Error,
     Info,
+    Print,
     Warning,
     Watcher,
     Debug,
@@ -33,6 +34,22 @@ impl Logger {
         // no-op for WASM
     }
 
+    // --- log_message_with_trace ---
+
+    #[cfg(feature = "cli")]
+    pub fn log_message_with_trace(&self, level: LogLevel, message: &str, trace: Vec<&str>) {
+        let formatted_status = self.format_status(level);
+        println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
+        for t in trace {
+            println!("     ↳ {}", t);
+        }
+    }
+
+    #[cfg(not(feature = "cli"))]
+    pub fn log_message_with_trace(&self, _level: LogLevel, _message: &str, _trace: Vec<&str>) {
+        // no-op for WASM
+    }
+
     // --- log_error_with_stacktrace ---
 
     #[cfg(feature = "cli")]
@@ -86,6 +103,7 @@ impl Logger {
             LogLevel::Warning => Color::Rgb { r: 255, g: 152, b: 0 },
             LogLevel::Watcher => Color::Rgb { r: 156, g: 39, b: 176 },
             LogLevel::Debug => Color::Rgb { r: 103, g: 58, b: 183 },
+            LogLevel::Print => Color::Rgb { r: 255, g: 255, b: 255 },
         };
 
         let status = match level {
@@ -95,6 +113,7 @@ impl Logger {
             LogLevel::Warning => "WARNING",
             LogLevel::Watcher => "WATCHER",
             LogLevel::Debug => "DEBUG",
+            LogLevel::Print => "PRINT",
         };
 
         s.push('[');
@@ -117,6 +136,7 @@ impl Logger {
             LogLevel::Warning => "[WARNING]",
             LogLevel::Watcher => "[WATCHER]",
             LogLevel::Debug => "[DEBUG]",
+            LogLevel::Print => "[PRINT]",
         }
         .to_string()
     }

package/rust/utils/mod.rs

@@ -4,47 +4,4 @@ pub mod spinner;
 pub mod watcher;
 pub mod file;
 pub mod logger;
-
-use crate::core::parser::statement::{Statement, StatementKind};
-use crate::core::error::ErrorResult;
-use crate::core::shared::value::Value;
-
-pub fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
-    let mut errors: Vec<ErrorResult> = Vec::new();
-
-    for stmt in statements {
-        match &stmt.kind {
-            StatementKind::Unknown => {
-                errors.push(ErrorResult {
-                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
-                    line: stmt.line,
-                    column: stmt.column,
-                });
-            }
-            StatementKind::Error { message } => {
-                errors.push(ErrorResult {
-                    message: message.clone(),
-                    line: stmt.line,
-                    column: stmt.column,
-                });
-            }
-            StatementKind::Loop => {
-                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
-                    errors.extend(collect_errors_recursively(body_statements));
-                }
-            }
-            _ => {}
-        }
-    }
-
-    errors
-}
-
-pub fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
-    if let Value::Map(map) = value {
-        if let Some(Value::Block(statements)) = map.get("body") {
-            return Some(statements);
-        }
-    }
-    None
-}
+pub mod error;

package/rust/utils/spinner.rs

@@ -3,7 +3,7 @@ use indicatif::{ ProgressBar, ProgressStyle };
 use std::{ time::Duration };
 
 #[cfg(feature = "cli")]
-pub fn with_spinner<T, F>(start_msg: &str, f: F) -> T where F: FnOnce() -> T {
+pub fn with_spinner<T, F>(start_msg: &str, f: F) -> ProgressBar where F: FnOnce() -> T {
     let spinner = ProgressBar::new_spinner();
     spinner.set_style(
         ProgressStyle::with_template("{spinner:.green} {msg}")
@@ -13,9 +13,7 @@ pub fn with_spinner<T, F>(start_msg: &str, f: F) -> T where F: FnOnce() -> T {
     spinner.set_message(start_msg.to_string());
     spinner.enable_steady_tick(Duration::from_millis(80));
 
-    let result = f();
+    let _ = f();
 
-    spinner.finish_and_clear();
-
-    result
+    spinner
 }