@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.11

package/rust/lib.rs

@@ -1 +1,162 @@
-// TODO WebAssembly support
+pub mod core;
+pub mod utils;
+pub mod config;
+pub mod common;
+
+use serde::{ Deserialize, Serialize };
+use wasm_bindgen::prelude::*;
+use serde_wasm_bindgen::to_value;
+
+use crate::core::{
+    audio::{ engine::AudioEngine, interpreter::driver::{ run_audio_program } },
+    parser::statement::{ Statement, StatementKind },
+    preprocessor::loader::ModuleLoader,
+    shared::value::Value,
+    store::global::GlobalStore,
+    utils::path::normalize_path,
+};
+
+#[derive(Serialize, Deserialize)]
+struct ParseResult {
+    ok: bool,
+    ast: String,
+    errors: Vec<ErrorResult>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct ErrorResult {
+    message: String,
+    line: usize,
+    column: usize,
+}
+
+#[wasm_bindgen]
+pub fn parse(entry_path: &str, source: &str) -> Result<JsValue, JsValue> {
+    let statements = parse_internal_from_string(entry_path, source);
+
+    match statements {
+        Ok(value) => {
+            let ast_string = value;
+            to_value(&ast_string).map_err(|e|
+                JsValue::from_str(&format!("Error converting AST to JS value: {}", e))
+            )
+        }
+        Err(e) => { Err(JsValue::from_str(&format!("Error: {}", e))) }
+    }
+}
+
+#[wasm_bindgen]
+pub fn render_audio(user_code: &str) -> Result<js_sys::Float32Array, JsValue> {
+    let entry_path = normalize_path("playground.deva");
+    let output_path = normalize_path("./temp");
+
+    let mut global_store = GlobalStore::new();
+
+    let loader = ModuleLoader::from_raw_source(
+        &entry_path,
+        &output_path,
+        user_code,
+        &mut global_store
+    );
+
+    loader
+        .load_wasm_module(&mut global_store)
+        .map_err(|e| JsValue::from_str(&format!("Module loading error: {}", e)))?;
+
+    let all_statements_map = loader.extract_statements_map(&global_store);
+
+    let main_statements = all_statements_map
+        .get(&entry_path)
+        .ok_or(JsValue::from_str("❌ No statements found for entry module"))?
+        .clone();
+
+    let audio_engine = AudioEngine::new("wasm_output".to_string());
+
+    let (final_engine, _, _) = run_audio_program(
+        &main_statements,
+        audio_engine,
+        "playground".to_string(),
+        "wasm_output".to_string()
+    );
+
+    let samples = final_engine.get_normalized_buffer();
+
+    if samples.is_empty() {
+        return Err(JsValue::from_str("❌ Audio buffer is empty"));
+    }
+
+    Ok(js_sys::Float32Array::from(samples.as_slice()))
+}
+
+fn parse_internal_from_string(virtual_path: &str, source: &str) -> Result<ParseResult, String> {
+    let entry_path = normalize_path(virtual_path);
+    let output_path = normalize_path("./temp");
+
+    let mut global_store = GlobalStore::new();
+    let loader = ModuleLoader::from_raw_source(
+        &entry_path,
+        &output_path,
+        source,
+        &mut global_store
+    );
+
+    let module = loader
+        .load_single_module(&mut global_store)
+        .map_err(|e| format!("Error loading module: {}", e))?;
+
+    let raw_ast = ast_to_string(module.statements.clone());
+
+    let found_errors = collect_errors_recursively(&module.statements);
+
+    let result = ParseResult {
+        ok: true,
+        ast: raw_ast,
+        errors: found_errors,
+    };
+
+    Ok(result)
+}
+
+fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    errors.extend(collect_errors_recursively(body_statements));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}
+
+fn ast_to_string(statements: Vec<Statement>) -> String {
+    serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
+}

package/rust/main.rs

@@ -1,48 +1,121 @@
+#![cfg(feature = "cli")]
+
 pub mod core;
 pub mod cli;
-pub mod runner;
-pub mod audio;
 pub mod utils;
+pub mod config;
+pub mod common;
+pub mod installer;
 
-use std::{ io };
+use std::io;
 use clap::Parser;
 use crate::{
-    cli::{ build::handle_build_command, check::handle_check_command },
-    core::types::cli::{ Cli, CliCommands },
+    cli::{
+        bank::{
+            handle_bank_available_command,
+            handle_bank_info_command,
+            handle_bank_list_command,
+            handle_remove_bank_command, handle_update_bank_command,
+        },
+        build::handle_build_command,
+        check::handle_check_command,
+        driver::{ BankCommand, Cli, Commands, InstallCommand, TemplateCommand },
+        init::handle_init_command,
+        install::handle_install_bank_command,
+        play::handle_play_command,
+        template::{ handle_template_info_command, handle_template_list_command },
+        update::handle_update_command,
+    },
+    config::{ driver::Config, loader::load_config },
 };
 
-fn main() -> io::Result<()> {
-    let cli = Cli::parse();
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    let cli: Cli = Cli::parse();
+    let mut config: Option<Config> = None;
+
+    if !cli.no_config {
+        config = load_config(None);
+    } else {
+        println!("No configuration file loaded. Running with arguments only.");
+    }
 
     match cli.command {
-        // TODO - Implement the new command
-        // CliCommands::New { name, template } => {
-        //     log_message("Command 'new project' is not implemented yet.", "WARNING");
-        // }
-
-        // TODO - Implement the template command
-        // CliCommands::Template { command } =>
-        //     match command {
-        //         CliTemplateCommand::List => {
-        //             log_message("Command 'template list' is not implemented yet.", "WARNING");
-        //         }
-        //         CliTemplateCommand::Info { name } => {
-        //             log_message("Command 'template info' is not implemented yet.", "WARNING");
-        //         }
-        //     }
-
-        CliCommands::Build { entry, output, watch, compilation_mode, debug, compress } => {
-            handle_build_command(entry, output);
+        Commands::Init { name, template } => {
+            handle_init_command(name, template);
+        }
+
+        Commands::Template { command } =>
+            match command {
+                TemplateCommand::List => {
+                    handle_template_list_command();
+                }
+                TemplateCommand::Info { name } => {
+                    handle_template_info_command(name);
+                }
+            }
+
+        Commands::Check { entry, output, watch, compilation_mode, debug } => {
+            handle_check_command(config, entry, output, watch);
+        }
+
+        Commands::Build { entry, output, watch, compilation_mode, debug, compress } => {
+            handle_build_command(config, entry, output, watch);
         }
 
-        CliCommands::Check { entry, output, watch, compilation_mode, debug } => {
-            handle_check_command(entry, output);
+        Commands::Play { entry, output, watch, repeat } => {
+            handle_play_command(config, entry, output, watch, repeat);
+        }
+
+        Commands::Install { command } =>
+            match command {
+                InstallCommand::Bank { name } => {
+                    if let Err(err) = handle_install_bank_command(name).await {
+                        eprintln!("❌ Failed to install bank: {}", err);
+                    }
+                }
+            }
+
+        Commands::Bank { command } =>
+            match command {
+                BankCommand::List => {
+                    if let Err(err) = handle_bank_list_command().await {
+                        eprintln!("❌ Failed to list local banks: {}", err);
+                    }
+                }
+
+                BankCommand::Available => {
+                    if let Err(err) = handle_bank_available_command().await {
+                        eprintln!("❌ Failed to list available banks: {}", err);
+                    }
+                }
+
+                BankCommand::Info { name } => {
+                    if let Err(err) = handle_bank_info_command(name).await {
+                        eprintln!("❌ Failed to get bank info: {}", err);
+                    }
+                }
+
+                BankCommand::Remove { name } => {
+                    if let Err(err) = handle_remove_bank_command(name).await {
+                        eprintln!("❌ Failed to remove bank: {}", err);
+                    }
+                }
+
+                BankCommand::Update { name } => {
+                    if let Err(err) = handle_update_bank_command(name).await {
+                        eprintln!("❌ Failed to update bank: {}", err);
+                    }
+                }
+            }
+
+        Commands::Update { only } => {
+            if let Err(err) = handle_update_command(only).await {
+                eprintln!("❌ Update failed: {}", err);
+            }
         }
 
-        // TODO - Implement the play command
-        // CliCommands::Play {} => {
-        //     log_message("Command 'play' is not implemented yet.", "WARNING");
-        // }
+        _ => {}
     }
 
     Ok(())

package/rust/utils/file.rs

@@ -0,0 +1,35 @@
+use std::{ fs::{ self }, path::Path };
+use include_dir::{ Dir, DirEntry };
+
+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) => {
+                let rel_path = file.path().strip_prefix(base_path).unwrap();
+                let dest_path = target_root.join(rel_path);
+
+                if let Some(parent) = dest_path.parent() {
+                    fs::create_dir_all(parent).unwrap();
+                }
+
+                fs::write(&dest_path, file.contents()).expect("Error writing file");
+            }
+        }
+    }
+}
+
+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)
+    }
+}

package/rust/utils/installer.rs

@@ -0,0 +1,56 @@
+use std::fs::File;
+use std::path::Path;
+use std::io::BufReader;
+use std::error::Error;
+use std::io::{ copy, Cursor };
+use zip::ZipArchive;
+
+pub async fn download_file(url: &str, destination: &Path) -> Result<(), Box<dyn Error>> {
+    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(())
+}
+
+pub async fn extract_archive(
+    zip_path: &Path,
+    destination: &Path
+) -> Result<(), Box<dyn std::error::Error>> {
+    let file = File::open(zip_path)?;
+    let mut archive = ZipArchive::new(BufReader::new(file))?;
+
+    for i in 0..archive.len() {
+        let mut file = archive.by_index(i)?;
+        let outpath = destination.join(file.mangled_name());
+
+        if file.name().ends_with('/') {
+            std::fs::create_dir_all(&outpath)?;
+        } else {
+            if let Some(p) = outpath.parent() {
+                std::fs::create_dir_all(p)?;
+            }
+
+            let mut outfile = File::create(&outpath)?;
+            std::io::copy(&mut file, &mut outfile)?;
+        }
+    }
+
+    // Clear the temporary folder after extraction
+    if zip_path.exists() {
+        std::fs::remove_file(zip_path)?;
+    }
+
+    Ok(())
+}

package/rust/utils/logger.rs

@@ -1,49 +1,123 @@
+#[cfg(feature = "cli")]
 use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
-use std::{ fmt::Write };
+use std::fmt::Write;
 
-pub fn log_message(message: &str, status: &str) {
-    let formatted_status = format_status(status);
-    println!("🦊 {} {} {}", language_signature(), formatted_status, message);
+#[derive(Debug, Clone, PartialEq)]
+pub enum LogLevel {
+    Success,
+    Error,
+    Info,
+    Warning,
+    Watcher,
+    Debug,
 }
 
-fn language_signature() -> String {
-    let mut s = String::new();
+#[derive(Debug, Clone)]
+pub struct Logger;
 
-    write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
-    s.push('[');
+impl Logger {
+    pub fn new() -> Self {
+        Logger
+    }
 
-    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();
+    // --- log_message ---
 
-    write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
-    s.push(']');
+    #[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);
+    }
 
-    write!(&mut s, "{}", ResetColor).unwrap();
+    #[cfg(not(feature = "cli"))]
+    pub fn log_message(&self, _level: LogLevel, _message: &str) {
+        // no-op for WASM
+    }
 
-    s
-}
+    // --- 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();
 
-fn format_status(status: &str) -> 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 color = match status {
-        "SUCCESS" => Color::Rgb { r: 76, g: 175, b: 80 },
-        "ERROR" => Color::Rgb { r: 244, g: 67, b: 54 },
-        "INFO" => Color::Rgb { r: 33, g: 150, b: 243 },
-        "WARNING" => Color::Rgb { r: 255, g: 152, b: 0 },
-        _ => Color::Grey,
-    };
+        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(']');
+        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();
 
-    write!(&mut s, "{}", ResetColor).unwrap();
+        s
+    }
 
-    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()
+    }
 }

package/rust/utils/mod.rs

@@ -1,5 +1,7 @@
 pub mod version;
 pub mod signature;
-pub mod path;
-pub mod loader;
-pub mod logger;
+pub mod spinner;
+pub mod watcher;
+pub mod file;
+pub mod logger;
+pub mod installer;

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

@@ -1,6 +1,8 @@
+#[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(

package/rust/utils/watcher.rs

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

package/templates/minimal/.devalang

@@ -0,0 +1,5 @@
+[defaults]
+entry = "./src"
+output = "./output"
+watch = false
+repeat = false