@devaloop/devalang 0.0.1-alpha.14 → 0.0.1-alpha.16

package/rust/main.rs

@@ -1,145 +1,250 @@
-#![cfg(feature = "cli")]
-
-pub mod core;
-pub mod cli;
-pub mod utils;
-pub mod config;
-pub mod common;
-pub mod installer;
-
-use std::io;
-use clap::Parser;
-use crate::{
-    cli::{
-        bank::{
-            handle_bank_available_command,
-            handle_bank_info_command,
-            handle_bank_list_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_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]
-async fn main() -> io::Result<()> {
-    let cli: Cli = Cli::parse();
-    let mut config: Option<Config> = None;
-
-    if !cli.no_config {
-        config = load_config(None);
-    } else {
-        println!("No configuration file loaded. Running with arguments only.");
-    }
-
-    match cli.command {
-        Commands::Init { name, template } => {
-            handle_init_command(name, template);
-        }
-
-        Commands::Template { command } =>
-            match command {
-                TemplateCommand::List => {
-                    handle_template_list_command();
-                }
-                TemplateCommand::Info { name } => {
-                    handle_template_info_command(name);
-                }
-            }
-
-        Commands::Check { entry, output, watch, debug } => {
-            handle_check_command(config, entry, output, watch, debug);
-        }
-
-        Commands::Build { entry, output, watch, debug, compress } => {
-            handle_build_command(config, entry, output, watch, debug, compress);
-        }
-
-        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_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 } =>
-            match command {
-                BankCommand::List => {
-                    if let Err(err) = handle_bank_list_command().await {
-                        eprintln!("❌ Failed to list local banks: {}", err);
-                    }
-                }
-
-                BankCommand::Available => {
-                    if let Err(err) = handle_bank_available_command().await {
-                        eprintln!("❌ Failed to list available banks: {}", err);
-                    }
-                }
-
-                BankCommand::Info { name } => {
-                    if let Err(err) = handle_bank_info_command(name).await {
-                        eprintln!("❌ Failed to get bank info: {}", err);
-                    }
-                }
-
-                BankCommand::Remove { name } => {
-                    if let Err(err) = handle_remove_bank_command(name).await {
-                        eprintln!("❌ Failed to remove bank: {}", err);
-                    }
-                }
-
-                BankCommand::Update { name } => {
-                    if let Err(err) = handle_update_bank_command(name).await {
-                        eprintln!("❌ Failed to update bank: {}", err);
-                    }
-                }
-            }
-
-        Commands::Update { only } => {
-            if let Err(err) = handle_update_command(only).await {
-                eprintln!("❌ Update failed: {}", err);
-            }
-        }
-
-        Commands::Login { .. } => {
-            if let Err(err) = handle_login_command().await {
-                eprintln!("❌ Login failed: {}", err);
-            }
-        }
-
-        Commands::Logout { .. } => {
-            eprintln!("❌ Logout command is not implemented yet.");
-        }
-
-        _ => {}
-    }
-
-    Ok(())
-}
+#![cfg(feature = "cli")]
+
+pub mod cli;
+pub mod common;
+pub mod config;
+pub mod core;
+pub mod installer;
+pub mod utils;
+
+use crate::{
+    cli::{
+        bank::{
+            handle_bank_available_command, handle_bank_info_command, handle_bank_list_command,
+            handle_remove_bank_command, handle_update_bank_command,
+        },
+        build::handle_build_command,
+        check::handle_check_command,
+        driver::{BankCommand, Cli, Commands, InstallCommand, TelemetryCommand, TemplateCommand},
+        init::handle_init_command,
+        install::handle_install_command,
+        login::handle_login_command,
+        play::handle_play_command,
+        telemetry::{handle_telemetry_disable_command, handle_telemetry_enable_command},
+        template::{handle_template_info_command, handle_template_list_command},
+        update::handle_update_command,
+    },
+    config::{driver::ProjectConfig, loader::load_config},
+    installer::addon::AddonType,
+    utils::{first_usage::check_is_first_usage, telemetry::TelemetryEventCreator},
+};
+use clap::Parser;
+use std::io;
+
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    let cli: Cli = Cli::parse();
+    let mut config: Option<ProjectConfig> = None;
+
+    let duration = std::time::Instant::now();
+
+    check_is_first_usage();
+
+    let telemetry_event_creator = TelemetryEventCreator::new();
+    let mut event = telemetry_event_creator.get_base_event();
+    let mut had_error: bool = false;
+    let mut last_error_message: Option<String> = None;
+    let mut exit_code: Option<i32> = None;
+
+    if !cli.no_config {
+        config = load_config(None);
+    } else {
+        println!("No configuration file loaded. Running with arguments only.");
+    }
+
+    match cli.command {
+        Commands::Init { name, template } => {
+            handle_init_command(name, template);
+        }
+
+        Commands::Template { command } => match command {
+            TemplateCommand::List => {
+                handle_template_list_command();
+            }
+            TemplateCommand::Info { name } => {
+                handle_template_info_command(name);
+            }
+        },
+
+        Commands::Check {
+            entry,
+            output,
+            watch,
+            debug,
+        } => {
+            if let Err(err) = handle_check_command(config, entry, output, watch, debug) {
+                eprintln!("❌ Check failed: {}", err);
+                had_error = true;
+                last_error_message = Some(format!("check failed: {}", err));
+                exit_code = Some(1);
+            }
+        }
+
+        Commands::Build {
+            entry,
+            output,
+            watch,
+            debug,
+            compress,
+        } => {
+            if let Err(err) = handle_build_command(config, entry, output, watch, debug, compress) {
+                eprintln!("❌ Build failed: {}", err);
+                had_error = true;
+                last_error_message = Some(format!("build failed: {}", err));
+                exit_code = Some(1);
+            }
+        }
+
+        Commands::Play {
+            entry,
+            output,
+            watch,
+            repeat,
+            debug,
+        } => {
+            if let Err(err) = handle_play_command(config, entry, output, watch, repeat, debug) {
+                eprintln!("❌ Play failed: {}", err);
+                had_error = true;
+                last_error_message = Some(format!("play failed: {}", err));
+                exit_code = Some(1);
+            }
+        }
+
+        Commands::Install { command } => match command {
+            InstallCommand::Bank { name } => {
+                if let Err(err) = handle_install_command(name, AddonType::Bank).await {
+                    eprintln!("❌ Failed to install bank: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("install bank failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+            InstallCommand::Plugin { name } => {
+                if let Err(err) = handle_install_command(name, AddonType::Plugin).await {
+                    eprintln!("❌ Failed to install plugin: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("install plugin failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+            InstallCommand::Preset { name } => {
+                if let Err(err) = handle_install_command(name, AddonType::Preset).await {
+                    eprintln!("❌ Failed to install preset: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("install preset failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+        },
+
+        Commands::Bank { command } => match command {
+            BankCommand::List => {
+                if let Err(err) = handle_bank_list_command().await {
+                    eprintln!("❌ Failed to list local banks: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("bank list failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+
+            BankCommand::Available => {
+                if let Err(err) = handle_bank_available_command().await {
+                    eprintln!("❌ Failed to list available banks: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("bank available failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+
+            BankCommand::Info { name } => {
+                if let Err(err) = handle_bank_info_command(name).await {
+                    eprintln!("❌ Failed to get bank info: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("bank info failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+
+            BankCommand::Remove { name } => {
+                if let Err(err) = handle_remove_bank_command(name).await {
+                    eprintln!("❌ Failed to remove bank: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("bank remove failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+
+            BankCommand::Update { name } => {
+                if let Err(err) = handle_update_bank_command(name).await {
+                    eprintln!("❌ Failed to update bank: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("bank update failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+        },
+
+        Commands::Update { only } => {
+            if let Err(err) = handle_update_command(only).await {
+                eprintln!("❌ Update failed: {}", err);
+                had_error = true;
+                last_error_message = Some(format!("update failed: {}", err));
+                exit_code = Some(1);
+            }
+        }
+
+        Commands::Telemetry { command } => match command {
+            TelemetryCommand::Enable { .. } => {
+                if let Err(err) = handle_telemetry_enable_command().await {
+                    eprintln!("❌ Failed to enable telemetry: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("telemetry enable failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+            TelemetryCommand::Disable { .. } => {
+                if let Err(err) = handle_telemetry_disable_command().await {
+                    eprintln!("❌ Failed to disable telemetry: {}", err);
+                    had_error = true;
+                    last_error_message = Some(format!("telemetry disable failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
+        },
+
+        Commands::Login { .. } => {
+            if let Err(err) = handle_login_command().await {
+                eprintln!("❌ Login failed: {}", err);
+                had_error = true;
+                last_error_message = Some(format!("login failed: {}", err));
+                exit_code = Some(1);
+            }
+        }
+
+        Commands::Logout { .. } => {
+            eprintln!("❌ Logout command is not implemented yet.");
+            had_error = true;
+            last_error_message = Some("logout not implemented".to_string());
+            exit_code = Some(1);
+        }
+    }
+
+    // SECTION Telemetry
+    event.set_timestamp(chrono::Utc::now().to_string());
+    event.set_duration(duration.elapsed().as_millis() as u64);
+    event.set_success(!had_error);
+
+    if had_error {
+        event.set_error(
+            utils::telemetry::TelemetryErrorLevel::Critical,
+            last_error_message,
+            exit_code,
+        );
+    }
+
+    utils::telemetry::refresh_event_project_info(&mut event);
+
+    let _ = utils::telemetry::send_telemetry_event(&event).await;
+
+    Ok(())
+}

package/rust/utils/error.rs

@@ -0,0 +1,200 @@
+use super::logger::{LogLevel, Logger};
+use crate::core::{
+    error::{ErrorResult, Severity, StackFrame},
+    parser::statement::{Statement, StatementKind},
+    shared::value::Value,
+};
+use std::collections::HashMap;
+
+/// 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,
+                    severity: Severity::Warning,
+                    stack: vec![StackFrame {
+                        module: None,
+                        context: Some("Unknown".to_string()),
+                        line: stmt.line,
+                        column: stmt.column,
+                    }],
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                    severity: Severity::Critical,
+                    stack: vec![StackFrame {
+                        module: None,
+                        context: Some("Error".to_string()),
+                        line: stmt.line,
+                        column: stmt.column,
+                    }],
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    let nested = collect_errors_recursively(body_statements);
+                    errors.extend(nested.into_iter().map(|mut e| {
+                        // push parent frame contextually for a basic callstack-like trace
+                        e.stack.insert(
+                            0,
+                            StackFrame {
+                                module: None,
+                                context: Some("loop".to_string()),
+                                line: stmt.line,
+                                column: stmt.column,
+                            },
+                        );
+                        e
+                    }));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    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
+}
+
+pub fn partition_errors(errors: Vec<ErrorResult>) -> (Vec<ErrorResult>, Vec<ErrorResult>) {
+    let mut warnings = Vec::new();
+    let mut criticals = Vec::new();
+    for e in errors {
+        match e.severity {
+            Severity::Warning => warnings.push(e),
+            Severity::Critical => criticals.push(e),
+        }
+    }
+    (warnings, criticals)
+}
+
+pub fn log_errors_with_stack(prefix: &str, warnings: &[ErrorResult], criticals: &[ErrorResult]) {
+    let logger = Logger::new();
+    if !warnings.is_empty() {
+        logger.log_message(
+            LogLevel::Warning,
+            &format!("{}: {} warning(s)", prefix, warnings.len()),
+        );
+        for w in warnings {
+            logger.log_message(LogLevel::Warning, &format!("- {}", w.message));
+            // Print primary location in path:line:col if available
+            if let Some(frame) = w.stack.first() {
+                let module = frame.module.clone().unwrap_or_default();
+                logger.log_message(
+                    LogLevel::Debug,
+                    &format!(
+                        "     ↳ {}:{}:{} {}",
+                        module,
+                        frame.line,
+                        frame.column,
+                        frame.context.clone().unwrap_or_default()
+                    ),
+                );
+            }
+            // Print remaining frames if any
+            if w.stack.len() > 1 {
+                for (i, f) in w.stack.iter().enumerate().skip(1) {
+                    let module = f.module.clone().unwrap_or_default();
+                    logger.log_message(
+                        LogLevel::Debug,
+                        &format!(
+                            "       #{} {}:{}:{} {}",
+                            i,
+                            module,
+                            f.line,
+                            f.column,
+                            f.context.clone().unwrap_or_default()
+                        ),
+                    );
+                }
+            }
+        }
+    }
+    if !criticals.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            &format!("{}: {} critical error(s)", prefix, criticals.len()),
+        );
+        for c in criticals {
+            logger.log_message(LogLevel::Error, &format!("- {}", c.message));
+            if let Some(frame) = c.stack.first() {
+                let module = frame.module.clone().unwrap_or_default();
+                logger.log_message(
+                    LogLevel::Error,
+                    &format!(
+                        "     ↳ {}:{}:{} {}",
+                        module,
+                        frame.line,
+                        frame.column,
+                        frame.context.clone().unwrap_or_default()
+                    ),
+                );
+            }
+            if c.stack.len() > 1 {
+                for (i, f) in c.stack.iter().enumerate().skip(1) {
+                    let module = f.module.clone().unwrap_or_default();
+                    logger.log_message(
+                        LogLevel::Error,
+                        &format!(
+                            "       #{} {}:{}:{} {}",
+                            i,
+                            module,
+                            f.line,
+                            f.column,
+                            f.context.clone().unwrap_or_default()
+                        ),
+                    );
+                }
+            }
+        }
+    }
+}
+
+pub fn collect_all_errors_with_modules(
+    modules: &HashMap<String, Vec<Statement>>,
+) -> Vec<ErrorResult> {
+    let mut all = Vec::new();
+    for (module_path, stmts) in modules {
+        let mut errs = collect_errors_recursively(stmts);
+        for e in errs.iter_mut() {
+            // ensure top frame carries the module path
+            if e.stack.is_empty() {
+                e.stack.push(StackFrame {
+                    module: Some(module_path.clone()),
+                    context: None,
+                    line: e.line,
+                    column: e.column,
+                });
+            } else {
+                if e.stack[0].module.is_none() {
+                    e.stack[0].module = Some(module_path.clone());
+                }
+            }
+        }
+        all.extend(errs);
+    }
+    all
+}

package/rust/utils/file.rs

@@ -1,35 +1,38 @@
-use std::{ fs::{ self }, path::Path };
-use include_dir::{ Dir, DirEntry };
-
-pub fn copy_dir_recursive(dir: &Dir, target_root: &Path, base_path: &Path) {
-    for entry in dir.entries() {
-        match entry {
-            DirEntry::Dir(subdir) => {
-                copy_dir_recursive(subdir, target_root, base_path);
-            }
-            DirEntry::File(file) => {
-                let rel_path = file.path().strip_prefix(base_path).unwrap();
-                let dest_path = target_root.join(rel_path);
-
-                if let Some(parent) = dest_path.parent() {
-                    fs::create_dir_all(parent).unwrap();
-                }
-
-                fs::write(&dest_path, file.contents()).expect("Error writing file");
-            }
-        }
-    }
-}
-
-pub fn format_file_size(bytes: u64) -> String {
-    const KB: u64 = 1024;
-    const MB: u64 = 1024 * 1024;
-
-    if bytes >= MB {
-        format!("{:.2} Mb", (bytes as f64) / (MB as f64))
-    } else if bytes >= KB {
-        format!("{:.2} Kb", (bytes as f64) / (KB as f64))
-    } else {
-        format!("{} bytes", bytes)
-    }
-}
+use include_dir::{Dir, DirEntry};
+use std::{
+    fs::{self},
+    path::Path,
+};
+
+pub fn copy_dir_recursive(dir: &Dir, target_root: &Path, base_path: &Path) {
+    for entry in dir.entries() {
+        match entry {
+            DirEntry::Dir(subdir) => {
+                copy_dir_recursive(subdir, target_root, base_path);
+            }
+            DirEntry::File(file) => {
+                let rel_path = file.path().strip_prefix(base_path).unwrap();
+                let dest_path = target_root.join(rel_path);
+
+                if let Some(parent) = dest_path.parent() {
+                    fs::create_dir_all(parent).unwrap();
+                }
+
+                fs::write(&dest_path, file.contents()).expect("Error writing file");
+            }
+        }
+    }
+}
+
+pub fn format_file_size(bytes: u64) -> String {
+    const KB: u64 = 1024;
+    const MB: u64 = 1024 * 1024;
+
+    if bytes >= MB {
+        format!("{:.2} Mb", (bytes as f64) / (MB as f64))
+    } else if bytes >= KB {
+        format!("{:.2} Kb", (bytes as f64) / (KB as f64))
+    } else {
+        format!("{} bytes", bytes)
+    }
+}