@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.3

package/rust/utils/src/path.rs

@@ -1,88 +1,158 @@
-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)
-}
+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> {
+    // Prefer Cargo-provided manifest dir when available (build-time / cargo run)
+    if let Ok(cargo_dir) = env::var("CARGO_MANIFEST_DIR") {
+        let p = PathBuf::from(cargo_dir);
+        if p.exists() {
+            return Some(p);
+        }
+    }
+
+    // At runtime (packaged binary) try to infer the package root from the
+    // binary location: walk upward from the running executable and look for
+    // common markers (package.json, project-version.json, Cargo.toml).
+    if let Ok(exe_path) = env::current_exe() {
+        if let Some(mut dir) = exe_path.parent().map(|p| p.to_path_buf()) {
+            loop {
+                if dir.join("package.json").exists()
+                    || dir.join("project-version.json").exists()
+                    || dir.join("Cargo.toml").exists()
+                {
+                    return Some(dir);
+                }
+
+                if let Some(parent) = dir.parent() {
+                    dir = parent.to_path_buf();
+                } else {
+                    break;
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// 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)
+}
+
+/// Finds the entry file given a path, returning the normalized path if found.
+/// If the path is a directory, it looks for `index.deva` inside it.
+/// Returns None if no valid entry file is found.
+pub fn find_entry_file(entry: &str) -> Option<String> {
+    let path = Path::new(entry);
+
+    if path.is_file() {
+        return Some(normalize_path(entry));
+    }
+
+    if path.is_dir() {
+        let candidate = path.join("index.deva");
+        if candidate.exists() {
+            return Some(normalize_path(&candidate));
+        }
+    }
+
+    None
+}
+
+/// Normalizes a path to use forward slashes and removes redundant components.
+pub fn normalize_path<P: AsRef<Path>>(path: P) -> String {
+    let path_buf = PathBuf::from(path.as_ref());
+    path_buf
+        .components()
+        .collect::<PathBuf>()
+        .to_string_lossy()
+        .replace('\\', "/")
+}
+
+/// Resolves a relative import path against a base path, normalizing the result.
+pub fn resolve_relative_path(base: &str, import: &str) -> String {
+    let base_path = Path::new(base).parent().unwrap_or_else(|| Path::new(""));
+    let full_path = base_path.join(import);
+    full_path
+        .components()
+        .collect::<PathBuf>()
+        .to_string_lossy()
+        .replace("\\", "/")
+}

package/rust/utils/src/signature.rs

@@ -1,41 +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
-}
+#[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/src/spinner.rs

@@ -1,20 +1,20 @@
-#[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
-}
+#[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

@@ -1,27 +1,58 @@
-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()
-}
+use crate::{ path::get_package_root, signature::get_signature };
+
+/// Returns the CLI version with a runtime-first strategy:
+/// 1. DEVALANG_CLI_VERSION env var
+/// 2. project-version.json located next to the running binary
+/// 3. package.json located in the package root
+/// 4. compile-time env!("CARGO_PKG_VERSION") as a last resort
+pub fn get_version() -> String {
+    // 1) env override
+    if let Ok(v) = std::env::var("DEVALANG_CLI_VERSION") {
+        if !v.trim().is_empty() {
+            return v;
+        }
+    }
+
+    // 2) project-version.json next to binary
+    if let Ok(exe) = std::env::current_exe() {
+        if let Some(bin_dir) = exe.parent() {
+            let pv = bin_dir.join("project-version.json");
+            if pv.exists() {
+                if let Ok(contents) = std::fs::read_to_string(pv) {
+                    if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&contents) {
+                        if let Some(v) = parsed.get("version").and_then(|s| s.as_str()) {
+                            return v.to_string();
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // 3) package.json via package root
+    if let Some(root) = get_package_root() {
+        let pkg = root.join("package.json");
+        if pkg.exists() {
+            if let Ok(contents) = std::fs::read_to_string(pkg) {
+                if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&contents) {
+                    if let Some(v) = parsed.get("version").and_then(|s| s.as_str()) {
+                        return v.to_string();
+                    }
+                }
+            }
+        }
+    }
+
+    // 4) compile-time fallback
+    let compile_time = option_env!("CARGO_PKG_VERSION").unwrap_or("0.0.0");
+    compile_time.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/src/watcher.rs

@@ -1,46 +1,46 @@
-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(())
-}
+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

@@ -1,5 +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()
-}
+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/auth.rs

@@ -0,0 +1,5 @@
+pub fn get_auth_url() -> String {
+    let auth_url = "https://auth.devalang.com";
+    // let auth_url = "http://127.0.0.1:8787";
+    auth_url.to_string()
+}

package/rust/web/cdn.rs

@@ -1,34 +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(())
-}
+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/forge.rs

@@ -0,0 +1,5 @@
+pub fn get_forge_api_url() -> String {
+    let forge_url = "https://forge.devalang.com";
+    // let forge_url = "http://127.0.0.1:9090";
+    forge_url.to_string()
+}

package/rust/web/mod.rs

@@ -1,3 +1,5 @@
 pub mod api;
+pub mod auth;
 pub mod cdn;
+pub mod forge;
 pub mod sso;