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

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

@@ -1,123 +1,200 @@
-#[cfg(feature = "cli")]
-use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
-use std::fmt::Write;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum LogLevel {
-    Success,
-    Error,
-    Info,
-    Warning,
-    Watcher,
-    Debug,
-}
-
-#[derive(Debug, Clone)]
-pub struct Logger;
-
-impl Logger {
-    pub fn new() -> Self {
-        Logger
-    }
-
-    // --- log_message ---
-
-    #[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);
-    }
-
-    #[cfg(not(feature = "cli"))]
-    pub fn log_message(&self, _level: LogLevel, _message: &str) {
-        // 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);
-        println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
-        println!("     ↳ {}", stacktrace);
-    }
-
-    #[cfg(not(feature = "cli"))]
-    pub fn log_error_with_stacktrace(&self, _message: &str, _stacktrace: &str) {
-        // no-op for WASM
-    }
-
-    // --- language_signature ---
-
-    #[cfg(feature = "cli")]
-    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, "{}", SetAttribute(Attribute::Bold)).unwrap();
-        s.push_str("Devalang");
-        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
-
-        write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
-        s.push(']');
-        write!(&mut s, "{}", ResetColor).unwrap();
-
-        s
-    }
-
-    #[cfg(not(feature = "cli"))]
-    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 },
-        };
-
-        let status = match level {
-            LogLevel::Success => "SUCCESS",
-            LogLevel::Error => "ERROR",
-            LogLevel::Info => "INFO",
-            LogLevel::Warning => "WARNING",
-            LogLevel::Watcher => "WATCHER",
-            LogLevel::Debug => "DEBUG",
-        };
-
-        s.push('[');
-        write!(&mut s, "{}", SetForegroundColor(color)).unwrap();
-        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
-        s.push_str(status);
-        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
-        s.push(']');
-        write!(&mut s, "{}", ResetColor).unwrap();
-
-        s
-    }
-
-    #[cfg(not(feature = "cli"))]
-    fn format_status(&self, level: LogLevel) -> String {
-        match level {
-            LogLevel::Success => "[SUCCESS]",
-            LogLevel::Error => "[ERROR]",
-            LogLevel::Info => "[INFO]",
-            LogLevel::Warning => "[WARNING]",
-            LogLevel::Watcher => "[WATCHER]",
-            LogLevel::Debug => "[DEBUG]",
-        }
-        .to_string()
-    }
-}
+#[cfg(feature = "cli")]
+use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
+#[cfg(feature = "cli")]
+use std::fmt::Write;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum LogLevel {
+    Success,
+    Error,
+    Info,
+    Print,
+    Warning,
+    Watcher,
+    Debug,
+}
+
+#[derive(Debug, Clone)]
+pub struct Logger;
+
+impl Logger {
+    pub fn new() -> Self {
+        Logger
+    }
+
+    // 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
+        );
+    }
+
+    #[cfg(not(feature = "cli"))]
+    pub fn log_message(&self, _level: LogLevel, _message: &str) {
+        // no-op for WASM
+    }
+
+    #[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!("     ↳ {}", stacktrace);
+    }
+
+    #[cfg(not(feature = "cli"))]
+    pub fn log_error_with_stacktrace(&self, _message: &str, _stacktrace: &str) {
+        // no-op for WASM
+    }
+
+    #[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, "{}", SetAttribute(Attribute::Bold)).unwrap();
+        s.push_str("Devalang");
+        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+
+        write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
+        s.push(']');
+        write!(&mut s, "{}", ResetColor).unwrap();
+
+        s
+    }
+
+    #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
+    fn language_signature(&self) -> String {
+        "[Devalang]".to_string()
+    }
+
+    #[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::Print => Color::Rgb {
+                r: 255,
+                g: 255,
+                b: 255,
+            },
+        };
+
+        let status = match level {
+            LogLevel::Success => "SUCCESS",
+            LogLevel::Error => "ERROR",
+            LogLevel::Info => "INFO",
+            LogLevel::Warning => "WARNING",
+            LogLevel::Watcher => "WATCHER",
+            LogLevel::Debug => "DEBUG",
+            LogLevel::Print => "PRINT",
+        };
+
+        s.push('[');
+        write!(&mut s, "{}", SetForegroundColor(color)).unwrap();
+        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
+        s.push_str(status);
+        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+        s.push(']');
+        write!(&mut s, "{}", ResetColor).unwrap();
+
+        s
+    }
+
+    #[cfg(not(feature = "cli"))]
+    #[allow(dead_code)]
+    fn format_status(&self, level: LogLevel) -> String {
+        (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()
+    }
+}

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,21 +1,20 @@
-#[cfg(feature = "cli")]
-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 {
-    let spinner = ProgressBar::new_spinner();
-    spinner.set_style(
-        ProgressStyle::with_template("{spinner:.green} {msg}")
-            .unwrap()
-            .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"])
-    );
-    spinner.set_message(start_msg.to_string());
-    spinner.enable_steady_tick(Duration::from_millis(80));
-
-    let result = f();
-
-    spinner.finish_and_clear();
-
-    result
-}
+#[cfg(feature = "cli")]
+use indicatif::{ProgressBar, ProgressStyle};
+#[cfg(feature = "cli")]
+use std::time::Duration;
+
+#[cfg(feature = "cli")]
+pub fn start_spinner(start_msg: &str) -> ProgressBar {
+    let spinner = ProgressBar::new_spinner();
+    spinner.set_style(
+        ProgressStyle::with_template("{spinner:.green} {msg}")
+            .unwrap()
+            .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]),
+    );
+    spinner.set_message(start_msg.to_string());
+    spinner.enable_steady_tick(Duration::from_millis(80));
+
+    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}

@@ -1,33 +1,46 @@
-use notify::{ Watcher, RecursiveMode, Config, RecommendedWatcher };
-use std::sync::mpsc::channel;
-
-use std::time::{ Duration, Instant };
-
-pub fn watch_directory<F>(entry: String, callback: F) -> notify::Result<()>
-    where F: Fn() + Send + 'static
-{
-    let (tx, rx) = channel();
-
-    let mut watcher: RecommendedWatcher = Watcher::new(tx, Config::default())?;
-    watcher.watch(&entry.as_ref(), RecursiveMode::Recursive)?;
-
-    let mut last_trigger = Instant::now();
-
-    loop {
-        match rx.recv() {
-            Ok(_) => {
-                let now = Instant::now();
-                if now.duration_since(last_trigger) > Duration::from_millis(200) {
-                    callback();
-                    last_trigger = now;
-                }
-            }
-            Err(e) => {
-                eprintln!("Channel error: {:?}", e);
-                break;
-            }
-        }
-    }
-
-    Ok(())
-}
+use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
+use std::sync::mpsc::channel;
+
+use std::time::{Duration, Instant};
+
+pub fn watch_directory<F>(entry: String, callback: F) -> notify::Result<()>
+where
+    F: Fn() + Send + 'static,
+{
+    let (tx, rx) = channel();
+
+    let mut watcher: RecommendedWatcher = Watcher::new(tx, Config::default())?;
+    watcher.watch(&entry.as_ref(), RecursiveMode::Recursive)?;
+
+    let mut last_trigger = Instant::now();
+
+    loop {
+        match rx.recv() {
+            Ok(_) => {
+                let now = Instant::now();
+                if now.duration_since(last_trigger) > Duration::from_millis(200) {
+                    callback();
+                    last_trigger = now;
+                }
+            }
+            Err(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;
+            }
+        }
+    }
+
+    Ok(())
+}

package/rust/web/api.rs

@@ -0,0 +1,5 @@
+pub fn get_api_url() -> String {
+    let api_url = "https://api.devalang.com";
+    // let api_url = "http://127.0.0.1:8989";
+    api_url.to_string()
+}

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(())
+}

package/rust/web/mod.rs

@@ -0,0 +1,3 @@
+pub mod api;
+pub mod cdn;
+pub mod sso;

package/rust/web/sso.rs

@@ -0,0 +1,5 @@
+pub fn get_sso_url() -> String {
+    let sso_url = "https://sso.devalang.com";
+    // let sso_url = "http://localhost:5174";
+    sso_url.to_string()
+}