@devaloop/devalang 0.0.1-alpha.16-hotfix.1 → 0.0.1-alpha.17

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/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/templates/minimal/README.md

@@ -9,12 +9,15 @@
 ![Project Status](https://img.shields.io/badge/status-alpha-red)
 ![Version](https://img.shields.io/npm/v/@devaloop/devalang)
 ![License: MIT](https://img.shields.io/badge/license-MIT-green)
-![Platform](https://img.shields.io/badge/platform-Windows-blue)
+
+![Linux](https://img.shields.io/badge/linux-supported-blue?logo=linux)
+![macOS](https://img.shields.io/badge/macOS-supported-blue?logo=apple)
+![Windows](https://img.shields.io/badge/windows-supported-blue?logo=windows)
 
 ![npm](https://img.shields.io/npm/dt/@devaloop/devalang)
 ![crates](https://img.shields.io/crates/d/devalang)
 
-[![VSCode Extension](https://img.shields.io/visual-studio-marketplace/v/devaloop.devalang-vscode?label=VSCode%20Extension)](https://marketplace.visualstudio.com/items?itemName=devaloop.devalang-vscode)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/devaloop-labs/devalang/.github/workflows/ci.yml)
 
 # 🦊 Devalang (CORE) — Compose music with code
 
@@ -25,12 +28,13 @@ Whether you're building a track, shaping textures, or performing live, Devalang
 
 From studio sketches to live sets, Devalang gives you rhythmic control — with the elegance of code.
 
-> 🚧 Alpha Notice 🚧
+> **🚧 Notice 🚧**
+>
+> Includes synthesis, playback, and rendering features, but is still in early development, and breaking changes may occur.
 >
-> Includes synthesis, playback, and rendering features, but is still in early development.
+> **NEW**: [Devaforge is now available for creating addons](https://github.com/devaloop-labs/devaforge).
 >
-> Currently, Devalang CLI is only available for **Windows**.
-> Linux and macOS binaries will be added in future releases via cross-platform builds.
+> **NEW**: Now available for Windows, Linux, and macOS.
 
 ## 📚 Quick Access
 
@@ -41,81 +45,113 @@ From studio sketches to live sets, Devalang gives you rhythmic control — with
 - [📜 Changelog](./docs/CHANGELOG.md)
 - [💡 Examples](./examples/)
 - [🌐 Project Website](https://devalang.com)
-- [📦 Devalang CLI on npm](https://www.npmjs.com/package/@devaloop/devalang)
+- [📦 Devaforge on npm](https://www.npmjs.com/package/@devaloop/devaforge)
+- [📦 Devalang on npm](https://www.npmjs.com/package/@devaloop/devalang)
 
 ## ⏱️ Try it now !
 
 ### Try Devalang in your browser
 
-> Have a look at the [Playground](https://playground.devalang.com) to try Devalang directly in your browser
+> [Have a look at the Playground to try Devalang directly in your browser](https://playground.devalang.com)
 
-### Try Devalang CLI
+### Try Devalang in your terminal
+
+#### With Node.js
 
 ```bash
-# Install Devalang CLI globally
-npm install -g @devaloop/devalang
+npm install -g @devaloop/devalang@latest
+```
 
-# Create a new Devalang project
+#### With Rust
+
+```bash
+cargo install devalang
+```
+
+#### Initialize a new project (current directory)
+
+```bash
 devalang init --name my-project --template minimal
-cd my-project
 ```
 
+#### Write your first script
+
 Create a new Devalang file `src/index.deva` in the project directory:
 
 ```deva
 # src/index.deva
 
-group main:
-    let lead = synth sine {
+# BPM definition
+bpm 125
+
+# Bank picking (make sure you installed it)
+bank devaloop.808 as my808Bank
+
+group myGroup:
+    # Rhythmic (each beat playing a kick)
+    on beat:
+        .my808Bank.kick 1/4
+
+    # Synth definition with ADSR
+    let myLead = synth sine {
         attack: 0,
         decay: 100,
         sustain: 100,
         release: 100
     }
 
-    # Global automation for this synth (applies to subsequent notes)
-    automate lead:
+    # Global automation
+    automate myLead:
         param volume {
             0% = 0.0
-            100% = 1.0
-        }
-        param pan {
-            0% = -1.0
-            100% = 1.0
+            100% = 0.5
         }
         param pitch {
             0% = -12.0
             100% = 12.0
         }
 
-    lead -> note(C4, {
+    # Notes in a loop with condition
+    for i in [1, 2, 3]:
+        if i == 3:
+            myLead -> note(C5, { duration: 200 })
+            print "Playing note C5 for " + i
+
+    # Pause runtime for 500ms
+    sleep 500
+
+    # Note with automation
+    myLead -> note(C4, {
         duration: 400,
         velocity: 0.8,
-        automate: { pan: { 0%: -1.0, 100%: 0.0 } }
+        automate: {
+            pan: {
+                0%: -1.0,
+                100%: 0.0
+            }
+        }
     })
 
-    lead -> note(E4, { duration: 400 })
-    lead -> note(G4, { duration: 600, glide: true, target_freq: 659.25 })
-    lead -> note(B3, { duration: 400, slide: true, target_amp: 0.3 })
+    # Notes with params
+    myLead -> note(E4, { duration: 400 })
+    myLead -> note(G4, { duration: 600, glide: true, target_freq: 659.25 })
+    myLead -> note(B3, { duration: 400, slide: true, target_amp: 0.3 })
 
-    for i in [1, 2, 3]:
-        lead -> note(C5, { duration: 200 })
-
-# Play the lead
-
-call main
+# Calling the group to play it
+call myGroup
 ```
 
 ### And the best part ? You can play it directly from the command line:
 
+#### Play the script once
+
 ```bash
-# Play the Devalang file
 devalang play
+```
 
-# Play the Devalang file with watch mode
-devalang play --watch
+#### **LIVE mode** (repeat the playback + watch mode)
 
-# LIVE mode (repeat the playback + watch mode)
+```bash
 devalang play --repeat
 ```
 
@@ -125,40 +161,48 @@ devalang play --repeat
 
 ## ❓ Why Devalang ?
 
-- 🎹 Prototype audio ideas without opening a DAW, even VSCode
+- 🎹 Prototype audio ideas without opening a DAW, even VSCode with our Playground
 - 💻 Integrate sound into code-based workflows
 - 🎛️ Control audio parameters through readable syntax
 - 🧪 Build musical logic with variables and conditions
 - 🔄 Create complex patterns with ease
+- 🎚️ Automate everything
 
 ## 🚀 Features
 
-- 🎵 **Audio Engine**: Integrated audio playback and rendering
-- 🧩 **Module system** for importing and exporting variables between files
-- 📦 **Addon manager** for managing external banks, plugins and more
-- 📜 **Structured AST** generation for debugging and future compilation
-- 🔢 **Basic data types**: strings, numbers, booleans, maps, arrays
-- 👁️ **Watch mode** for `build`, `check` and `play` commands
-- 📂 **Project templates** for quick setup
-- 🎛️ **Custom samples**: easily load and trigger your own audio files
-- 🔄 **Looping and grouping**: create complex patterns with ease
+- ⚡ **Fast Build & Hot Reload** — optimized build process for quicker iteration.
+- 🎵 **Audio Engine & Real-time runner** — low-latency playback, render-to-file, and a realtime runner used by `devalang play` for live feedback.
+- ▶️ **Live mode (watch + repeat)** — edit and hear changes instantly with `devalang play --repeat` and watch mode.
+- 🧩 **Language primitives** — synths, notes, ADSR, maps, arrays, loops, conditionals and functions for expressive musical logic.
+- 🎛️ **Per-note automation & modulators** — `automate` maps, `$mod.*`, `$easing.*` and `$math.*` helpers for envelopes and LFOs.
+- 🧩 **Module system & structured AST** — import/export variables, stable AST output for debugging and tooling.
+- 🧰 **Plugins & Addons (WASM-ready)** — install plugins/banks, `@use` directive, and WASM plugin integration so plugins can render or process audio at runtime.
+- 📦 **Addon manager & Devaforge** — CLI commands to discover/install banks, plugins and templates; `devaforge` helps create addons.
+- ⚙️ **CLI tooling** — `build`, `check`, `play`, `install`, `init`, `discover`, `telemetry` and more with consistent flags (`--watch`, `--debug`, `--compress`).
+- 📂 **Project templates & examples** — quick-start templates and many example projects in `examples/`.
+- 🧑‍💻 **TypeScript API & WASM distribution** — Node-friendly package with TypeScript bindings and a WASM build for browser/Node usage.
+- 🧰 **Editor & formatting support** — VSCode extension and Prettier plugin to edit Devalang with syntax and formatting support.
+- 🎵 **Custom samples & banks** — drop samples into `.deva` and reference them from code; banks of sounds for fast composition.
+- 🔄 **Looping, grouping & scheduling** — precise beat-tied scheduling primitives for complex rhythmic patterns.
 
 ## 📄 Documentation
 
-### Please refer to the [online documentation](https://docs.devalang.com) for detailed information on syntax, features, and usage examples
+### [Please refer to the online documentation](https://docs.devalang.com) for detailed information on syntax, features, and usage examples
 
-## 🧯 Known issues
+## 📰 What's new
 
-- No smart modules yet, all groups, variables, and samples must be explicitly imported where used
-- No support yet for cross-platform builds (Linux, macOS)
+- **Devaforge**: Introduced a new system for creating and managing addons, including a CLI for addon generation.
+- **Documentation updates**: Improved documentation for clarity and completeness.
+- **Discovering addons**: Introduced a new command to detect addons.
+- **Public TypeScript API**: Added a public TypeScript API for easier integration.
+- **Improved error messages**: Enhanced error messages for better debugging.
+- **Bug fixes**: Various bug fixes and stability improvements.
 
 ## 🧪 Roadmap Highlights
 
 For more info, see [docs/ROADMAP.md](./docs/ROADMAP.md)
 
-- ⏳ Other statements (e.g `function`, `pattern`, ...)
-- ⏳ Cross-platform support (Linux, macOS)
-- ⏳ More built-in instruments (e.g. snare, hi-hat, etc.)
+- ⏳ Smart modules
 
 ## 🛡️ License