@devaloop/devalang 0.0.1-beta.3 → 0.1.1

package/rust/utils/src/first_usage.rs

@@ -1,97 +0,0 @@
-#[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/src/lib.rs

@@ -1,9 +0,0 @@
-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;

package/rust/utils/src/logger.rs

@@ -1,200 +0,0 @@
-#[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

@@ -1,158 +0,0 @@
-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 +0,0 @@
-#[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 +0,0 @@
-#[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,58 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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,5 +0,0 @@
-pub mod api;
-pub mod auth;
-pub mod cdn;
-pub mod forge;
-pub mod sso;