@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

package/rust/utils/src/error.rs

@@ -0,0 +1,186 @@
+use super::logger::{LogLevel, Logger};
+use devalang_types::{ErrorResult, Severity, StackFrame, Statement, StatementKind, Value};
+use std::collections::HashMap;
+
+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| {
+                        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));
+            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()
+                    ),
+                );
+            }
+            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() {
+            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/src/file.rs

@@ -0,0 +1,94 @@
+use include_dir::{Dir, DirEntry};
+use std::{fs, 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) => {
+                // Compute the destination path relative to the provided base.
+                let rel_path = match file.path().strip_prefix(base_path) {
+                    Ok(p) => p.to_owned(),
+                    Err(_) => {
+                        eprintln!(
+                            "Warning: failed to compute relative path for {:?}, skipping",
+                            file.path()
+                        );
+                        continue;
+                    }
+                };
+
+                let dest_path = target_root.join(rel_path);
+
+                if let Some(parent) = dest_path.parent() {
+                    if let Err(e) = fs::create_dir_all(parent) {
+                        eprintln!(
+                            "Warning: failed to create directory {}: {}",
+                            parent.display(),
+                            e
+                        );
+                        continue;
+                    }
+                }
+
+                if let Err(e) = fs::write(&dest_path, file.contents()) {
+                    eprintln!("Warning: failed to write {}: {}", dest_path.display(), e);
+                    continue;
+                }
+            }
+        }
+    }
+}
+
+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)
+    }
+}
+
+pub fn extract_zip_safely(archive_path: &Path, dest: &Path) -> Result<(), String> {
+    let file = std::fs::File::open(archive_path)
+        .map_err(|e| format!("Failed to open archive {}: {}", archive_path.display(), e))?;
+    let mut archive = zip::ZipArchive::new(file)
+        .map_err(|e| format!("Failed to read archive {}: {}", archive_path.display(), e))?;
+
+    for i in 0..archive.len() {
+        let mut file = archive
+            .by_index(i)
+            .map_err(|e| format!("Failed to access archive entry {}: {}", i, e))?;
+
+        let enclosed = match file.enclosed_name() {
+            Some(path) => path.to_owned(),
+            None => {
+                continue;
+            }
+        };
+
+        let outpath = dest.join(enclosed);
+
+        if file.name().ends_with('/') || file.is_dir() {
+            std::fs::create_dir_all(&outpath)
+                .map_err(|e| format!("Failed to create dir {}: {}", outpath.display(), e))?;
+        } else {
+            if let Some(p) = outpath.parent() {
+                std::fs::create_dir_all(p)
+                    .map_err(|e| format!("Failed to create parent {}: {}", p.display(), e))?;
+            }
+            let mut outfile = std::fs::File::create(&outpath)
+                .map_err(|e| format!("Failed to create file {}: {}", outpath.display(), e))?;
+            std::io::copy(&mut file, &mut outfile)
+                .map_err(|e| format!("Failed to write file {}: {}", outpath.display(), e))?;
+        }
+    }
+
+    Ok(())
+}

package/rust/utils/src/first_usage.rs

@@ -0,0 +1,97 @@
+#[cfg(feature = "cli")]
+use crossterm::style::{Attribute, SetAttribute};
+
+#[cfg(feature = "cli")]
+use std::fmt::Write;
+
+use crate::logger::{LogLevel, Logger};
+use crate::signature::get_signature;
+use crate::version::get_version;
+use std::env;
+use std::path::PathBuf;
+
+fn get_devalang_homedir() -> PathBuf {
+    // Prefer explicit env var, then HOME/USERPROFILE, fallback to current dir
+    if let Ok(p) = env::var("DEVALANG_HOME") {
+        return PathBuf::from(p);
+    }
+
+    if let Ok(p) = env::var("HOME") {
+        return PathBuf::from(p).join(".devalang");
+    }
+
+    if let Ok(p) = env::var("USERPROFILE") {
+        return PathBuf::from(p).join(".devalang");
+    }
+
+    env::current_dir()
+        .unwrap_or_else(|_| PathBuf::from("."))
+        .join(".devalang")
+}
+
+pub fn check_is_first_usage() -> bool {
+    if get_devalang_homedir().exists() == true {
+        false
+    } else {
+        first_usage_welcome();
+        true
+    }
+}
+
+pub fn first_usage_welcome() {
+    std::fs::create_dir_all(get_devalang_homedir()).ok();
+
+    let version = get_version();
+    print!("{}", get_signature(&version));
+
+    let homedir = get_devalang_homedir().display().to_string();
+
+    let welcome_msg = format!(
+        "Welcome to Devalang ! \n\
+        It looks like this is your first time using the tool.\n\
+        A configuration file will be created in your home directory.\n\
+        (location: '{}')",
+        homedir
+    );
+
+    #[cfg(feature = "cli")]
+    let mut s = String::new();
+    #[cfg(feature = "cli")]
+    {
+        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
+        write!(&mut s, "{}", welcome_msg).unwrap();
+        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+
+        println!("");
+        println!("{}", s);
+        println!("");
+    }
+
+    #[cfg(not(feature = "cli"))]
+    {
+        // Fallback: plain output on non-cli (wasm) builds
+        println!("");
+        println!("{}", welcome_msg);
+        println!("");
+    }
+
+    first_usage_ask_for_telemetry();
+}
+
+pub fn first_usage_ask_for_telemetry() {
+    let telemetry_msg = "Would you like to enable anonymous telemetry ?";
+    let telemetry_desc = "This data helps us improve the tool. You can opt-out at any time.";
+
+    // Non-interactive fallback for first usage: default to telemetry disabled.
+    let _ = telemetry_msg;
+    let _ = telemetry_desc;
+
+    let logger = Logger::new();
+
+    println!("");
+    logger.log_message(
+        LogLevel::Info,
+        "Telemetry disabled by default. You can enable it at any time by using 'devalang telemetry enable'"
+    );
+    println!("");
+}

package/rust/utils/{mod.rs → src/lib.rs}

@@ -1,6 +1,9 @@
-pub mod version;
+pub mod error;
+pub mod file;
+pub mod first_usage;
+pub mod logger;
+pub mod path;
 pub mod signature;
 pub mod spinner;
+pub mod version;
 pub mod watcher;
-pub mod file;
-pub mod logger;

package/rust/utils/{logger.rs → src/logger.rs}

@@ -1,5 +1,6 @@
 #[cfg(feature = "cli")]
 use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
+#[cfg(feature = "cli")]
 use std::fmt::Write;
 
 #[derive(Debug, Clone, PartialEq)]
@@ -7,6 +8,7 @@ pub enum LogLevel {
     Success,
     Error,
     Info,
+    Print,
     Warning,
     Watcher,
     Debug,
@@ -20,12 +22,25 @@ impl Logger {
         Logger
     }
 
-    // --- log_message ---
+    // Some methods are only used in CLI builds; silence dead_code warnings for non-cli.
+    #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
+    fn __wasm_only_allow_dead_code(&self) {}
+
+    // Additionally allow dead_code for the CLI-only formatting helpers when building without cli
+    #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
+    fn __wasm_only_format_helpers(&self) {}
 
     #[cfg(feature = "cli")]
     pub fn log_message(&self, level: LogLevel, message: &str) {
         let formatted_status = self.format_status(level);
-        println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
+        println!(
+            "🦊 {} {} {}",
+            self.language_signature(),
+            formatted_status,
+            message
+        );
     }
 
     #[cfg(not(feature = "cli"))]
@@ -33,12 +48,34 @@ impl Logger {
         // no-op for WASM
     }
 
-    // --- log_error_with_stacktrace ---
+    #[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
+    }
 
     #[cfg(feature = "cli")]
     pub fn log_error_with_stacktrace(&self, message: &str, stacktrace: &str) {
         let formatted_status = self.format_status(LogLevel::Error);
-        println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
+        println!(
+            "🦊 {} {} {}",
+            self.language_signature(),
+            formatted_status,
+            message
+        );
         println!("     ↳ {}", stacktrace);
     }
 
@@ -47,16 +84,25 @@ impl Logger {
         // no-op for WASM
     }
 
-    // --- language_signature ---
-
     #[cfg(feature = "cli")]
+    #[allow(dead_code)]
+    #[cfg_attr(not(feature = "cli"), allow(dead_code))]
     fn language_signature(&self) -> String {
         let mut s = String::new();
 
         write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
         s.push('[');
 
-        write!(&mut s, "{}", SetForegroundColor(Color::Rgb { r: 29, g: 211, b: 176 })).unwrap();
+        write!(
+            &mut s,
+            "{}",
+            SetForegroundColor(Color::Rgb {
+                r: 29,
+                g: 211,
+                b: 176,
+            })
+        )
+        .unwrap();
         write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
         s.push_str("Devalang");
         write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
@@ -69,23 +115,51 @@ impl Logger {
     }
 
     #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
     fn language_signature(&self) -> String {
         "[Devalang]".to_string()
     }
 
-    // --- format_status ---
-
     #[cfg(feature = "cli")]
     fn format_status(&self, level: LogLevel) -> String {
         let mut s = String::new();
 
         let color = match level {
-            LogLevel::Success => Color::Rgb { r: 76, g: 175, b: 80 },
-            LogLevel::Error => Color::Rgb { r: 244, g: 67, b: 54 },
-            LogLevel::Info => Color::Rgb { r: 33, g: 150, b: 243 },
-            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::Success => Color::Rgb {
+                r: 76,
+                g: 175,
+                b: 80,
+            },
+            LogLevel::Error => Color::Rgb {
+                r: 244,
+                g: 67,
+                b: 54,
+            },
+            LogLevel::Info => Color::Rgb {
+                r: 33,
+                g: 150,
+                b: 243,
+            },
+            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 +169,7 @@ impl Logger {
             LogLevel::Warning => "WARNING",
             LogLevel::Watcher => "WATCHER",
             LogLevel::Debug => "DEBUG",
+            LogLevel::Print => "PRINT",
         };
 
         s.push('[');
@@ -109,15 +184,17 @@ impl Logger {
     }
 
     #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
     fn format_status(&self, level: LogLevel) -> String {
-        match level {
+        (match level {
             LogLevel::Success => "[SUCCESS]",
             LogLevel::Error => "[ERROR]",
             LogLevel::Info => "[INFO]",
             LogLevel::Warning => "[WARNING]",
             LogLevel::Watcher => "[WATCHER]",
             LogLevel::Debug => "[DEBUG]",
-        }
+            LogLevel::Print => "[PRINT]",
+        })
         .to_string()
     }
 }