@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

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}

@@ -2,8 +2,8 @@ pub mod error;
 pub mod file;
 pub mod first_usage;
 pub mod logger;
+pub mod path;
 pub mod signature;
 pub mod spinner;
-pub mod telemetry;
 pub mod version;
 pub mod watcher;

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)]
@@ -21,7 +22,15 @@ 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) {
@@ -39,8 +48,6 @@ 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);
@@ -60,8 +67,6 @@ impl Logger {
         // no-op for WASM
     }
 
-    // --- log_error_with_stacktrace ---
-
     #[cfg(feature = "cli")]
     pub fn log_error_with_stacktrace(&self, message: &str, stacktrace: &str) {
         let formatted_status = self.format_status(LogLevel::Error);
@@ -79,9 +84,9 @@ 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();
 
@@ -94,7 +99,7 @@ impl Logger {
             SetForegroundColor(Color::Rgb {
                 r: 29,
                 g: 211,
-                b: 176
+                b: 176,
             })
         )
         .unwrap();
@@ -110,12 +115,11 @@ 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();
@@ -180,8 +184,9 @@ 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]",
@@ -189,7 +194,7 @@ impl Logger {
             LogLevel::Watcher => "[WATCHER]",
             LogLevel::Debug => "[DEBUG]",
             LogLevel::Print => "[PRINT]",
-        }
+        })
         .to_string()
     }
 }

package/rust/utils/src/path.rs

@@ -0,0 +1,88 @@
+use std::{
+    env, fs,
+    path::{Path, PathBuf},
+};
+
+pub const DEVALANG_CONFIG: &str = ".devalang";
+pub const DEVA_DIR: &str = ".deva";
+
+/// Returns the current working directory.
+pub fn get_cwd() -> PathBuf {
+    // In wasm (and some restricted environments) `env::current_dir()` is unsupported
+    // and will return an error. Avoid panicking here and fall back to `.` so the
+    // runtime can still operate in a virtual environment.
+    env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
+}
+
+/// Returns true if the given directory looks like a devalang project root.
+/// Preference is given to the presence of `.devalang` (config file),
+/// but falling back to a `.deva` directory is allowed.
+pub fn is_project_root(dir: &Path) -> bool {
+    let config = dir.join(DEVALANG_CONFIG);
+    if config.is_file() {
+        return true;
+    }
+    let deva = dir.join(DEVA_DIR);
+    deva.is_dir()
+}
+
+/// Walks upward from `start` to locate the first directory considered a project root.
+pub fn find_project_root_from(start: &Path) -> Option<PathBuf> {
+    for ancestor in start.ancestors() {
+        if is_project_root(ancestor) {
+            return Some(ancestor.to_path_buf());
+        }
+    }
+    None
+}
+
+/// Finds the project root from the current working directory.
+pub fn find_project_root() -> Option<PathBuf> {
+    find_project_root_from(&get_cwd())
+}
+
+/// Finds the package root using the `CARGO_MANIFEST_DIR` env var set by Cargo.
+pub fn get_package_root() -> Option<PathBuf> {
+    let cargo_dir = env::var("CARGO_MANIFEST_DIR").ok()?;
+    Some(PathBuf::from(cargo_dir))
+}
+
+/// Gets the project root or returns a descriptive error if not found.
+pub fn get_project_root() -> Result<PathBuf, String> {
+    find_project_root()
+        .ok_or_else(|| "Project root not found. Run 'devalang init' in your project.".to_string())
+}
+
+/// Returns the path to `.devalang` in the project root, ensuring it exists.
+pub fn get_devalang_config_path() -> Result<PathBuf, String> {
+    let root = get_project_root()?;
+    let config_path = root.join(DEVALANG_CONFIG);
+    if !config_path.exists() {
+        return Err(format!(
+            "Config file not found at '{}'. Please run 'devalang init' before continuing.",
+            config_path.display()
+        ));
+    }
+    Ok(config_path)
+}
+
+/// Returns the `.deva` directory inside the project root (without creating it).
+pub fn get_deva_dir() -> Result<PathBuf, String> {
+    let root = get_project_root()?;
+    Ok(root.join(DEVA_DIR))
+}
+
+/// Ensures the `.deva` directory exists in the project root and returns its path.
+pub fn ensure_deva_dir() -> Result<PathBuf, String> {
+    let deva = get_deva_dir()?;
+    if !deva.exists() {
+        fs::create_dir_all(&deva).map_err(|e| {
+            format!(
+                "Failed to create Deva directory '{}': {}",
+                deva.display(),
+                e
+            )
+        })?;
+    }
+    Ok(deva)
+}

package/rust/utils/src/signature.rs

@@ -0,0 +1,41 @@
+#[cfg(feature = "cli")]
+pub fn get_signature(version: &str) -> String {
+    let signature = format!(
+        r#"
+   /|_/|                    
+  / ^ ^(_o                  🦊 Devalang
+ /    __.'                  
+ /     \                    A programming language for music and sound.
+/  _   \_                   Part of the Devaloop project.
+(_) (_) '._                 
+  '.__     '. .-''-'.       https://devalang.com
+     ( '.   ('.____.''
+     _) )'_, )              v{}
+    (__/ (__/
+"#,
+        version
+    );
+
+    signature
+}
+
+#[cfg(not(feature = "cli"))]
+pub fn get_signature(version: &str) -> String {
+    let signature = format!(
+        r#"
+   /|_/|                    
+  / ^ ^(_o                  🦊 Devalang
+ /    __.'                  
+ /     \                    A programming language for music and sound.
+/  _   \_                   Part of the Devaloop project.
+(_) (_) '._                 
+  '.__     '. .-''-'.       https://devalang.com
+     ( '.   ('.____.''
+     _) )'_, )              v{}
+    (__/ (__/
+"#,
+        version
+    );
+
+    signature
+}

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

@@ -1,12 +1,10 @@
 #[cfg(feature = "cli")]
 use indicatif::{ProgressBar, ProgressStyle};
+#[cfg(feature = "cli")]
 use std::time::Duration;
 
 #[cfg(feature = "cli")]
-pub fn with_spinner<T, F>(start_msg: &str, f: F) -> ProgressBar
-where
-    F: FnOnce() -> T,
-{
+pub fn start_spinner(start_msg: &str) -> ProgressBar {
     let spinner = ProgressBar::new_spinner();
     spinner.set_style(
         ProgressStyle::with_template("{spinner:.green} {msg}")
@@ -16,7 +14,7 @@ where
     spinner.set_message(start_msg.to_string());
     spinner.enable_steady_tick(Duration::from_millis(80));
 
-    let _ = f();
+    std::thread::sleep(Duration::from_millis(750));
 
     spinner
 }

package/rust/utils/src/version.rs

@@ -0,0 +1,27 @@
+use crate::{path::get_package_root, signature::get_signature};
+
+pub fn get_version() -> String {
+    if let Some(root) = get_package_root() {
+        let project_version_json = root.join("project-version.json");
+        if let Ok(version) = std::fs::read_to_string(project_version_json) {
+            if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&version) {
+                if let Some(version_val) = parsed.get("version") {
+                    if let Some(s) = version_val.as_str() {
+                        return s.to_string();
+                    }
+                }
+            }
+        }
+    }
+
+    "0.0.0".to_string()
+}
+
+pub fn get_version_with_signature() -> String {
+    let version = get_version();
+    let signature = get_signature(&version);
+
+    println!("{}", signature);
+
+    "(c) 2025 Devaloop. All rights reserved.".to_string()
+}

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

@@ -24,7 +24,19 @@ where
                 }
             }
             Err(e) => {
-                eprintln!("Channel error: {:?}", e);
+                // Prefer structured logging when available
+                #[cfg(feature = "cli")]
+                {
+                    let logger = crate::logger::Logger::new();
+                    logger.log_message(
+                        crate::logger::LogLevel::Error,
+                        &format!("Channel error: {:?}", e),
+                    );
+                }
+                #[cfg(not(feature = "cli"))]
+                {
+                    eprintln!("Channel error: {:?}", e);
+                }
                 break;
             }
         }

package/rust/web/cdn.rs

@@ -0,0 +1,34 @@
+use std::error::Error;
+use std::fs::File;
+use std::io::{Cursor, copy};
+use std::path::Path;
+
+pub fn get_cdn_url() -> String {
+    let cdn_url = "https://cdn.devalang.com";
+    // let cdn_url = "http://127.0.0.1:8888";
+    cdn_url.to_string()
+}
+
+pub async fn download_from_cdn(url: &str, destination: &Path) -> Result<(), Box<dyn Error>> {
+    if !url.starts_with(&get_cdn_url()) {
+        return Err(format!("Invalid CDN URL: {}", url).into());
+    }
+
+    let response = reqwest::get(url).await?;
+
+    if !response.status().is_success() {
+        return Err(format!("Failed to download file: HTTP {}", response.status()).into());
+    }
+
+    if let Some(parent) = destination.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+
+    let bytes = response.bytes().await?;
+    let mut content = Cursor::new(bytes);
+    let mut file = File::create(destination)?;
+
+    copy(&mut content, &mut file)?;
+
+    Ok(())
+}