@devaloop/devalang 0.0.1-alpha.10 → 0.0.1-alpha.12

package/rust/core/parser/handler/dot.rs

@@ -6,14 +6,54 @@ use crate::core::{
 };
 
 pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume the dot token
+    parser.advance(); // consume the first dot
 
     let Some(dot_token) = parser.previous_clone() else {
         return Statement::unknown();
     };
 
-    // .kick
-    let Some(entity_token) = parser.peek_clone() else {
+    // Parse namespaced identifier: .808.kick.snare
+    let mut parts = Vec::new();
+
+    while let Some(token) = parser.peek_clone() {
+        match token.kind {
+            TokenKind::Number => {
+                // Stop if it's part of a duration
+                if let Some(TokenKind::Slash) = parser.peek_nth_kind(1) {
+                    break;
+                }
+
+                parts.push(token.lexeme.clone());
+                parser.advance();
+            }
+
+            TokenKind::Identifier => {
+                // Stop parsing entity name if next token is ':' or if already have one ident and current might be a param
+                if parts.len() >= 1 {
+                    break; // we've already got the entity
+                }
+
+                if token.lexeme == "auto" {
+                    break;
+                }
+
+                parts.push(token.lexeme.clone());
+                parser.advance();
+            }
+
+            TokenKind::Dot => {
+                parser.advance(); // continue chaining
+            }
+
+            _ => {
+                break;
+            }
+        }
+    }
+
+    let entity = if parts.len() == 1 { parts[0].clone() } else { parts[..=1].join(".") };
+
+    if entity.is_empty() {
         return Statement {
             kind: StatementKind::Trigger {
                 entity: String::new(),
@@ -24,68 +64,93 @@ pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
             line: dot_token.line,
             column: dot_token.column,
         };
-    };
-
-    parser.advance(); // consume entity
-    let entity = entity_token.lexeme.clone();
+    }
 
     // Check if there's a duration
     let next = parser.peek_clone();
 
     let (duration, value) = match next {
-        // If no more tokens, it's just `.kick`
         None => (Duration::Auto, Value::Null),
 
         Some(token) =>
             match token.kind {
-                TokenKind::Newline | TokenKind::EOF => { (Duration::Auto, Value::Null) }
+                TokenKind::Newline | TokenKind::EOF => (Duration::Auto, Value::Null),
 
                 TokenKind::Number => {
-                    let duration_lexeme = token.lexeme.clone();
-                    parser.advance(); // consume duration
+                    let numerator = token.lexeme.clone();
+                    parser.advance(); // consume numerator
+
+                    if let Some(TokenKind::Slash) = parser.peek_kind() {
+                        parser.advance(); // consume slash
+
+                        if let Some(denominator_token) = parser.peek_clone() {
+                            if denominator_token.kind == TokenKind::Number {
+                                let denominator = denominator_token.lexeme.clone();
+                                parser.advance(); // consume denominator
+
+                                let beat_str = format!("{}/{}", numerator, denominator);
+                                let beat_duration = Duration::Beat(beat_str);
+
+                                let val = match parser.peek_clone() {
+                                    Some(param_token) if
+                                        param_token.kind == TokenKind::Identifier
+                                    => {
+                                        parser.advance();
+                                        Value::Identifier(param_token.lexeme.clone())
+                                    }
+                                    Some(param_token) if param_token.kind == TokenKind::LBrace => {
+                                        parser.parse_map_value().unwrap_or(Value::Null)
+                                    }
+                                    _ => Value::Null,
+                                };
+
+                                return Statement {
+                                    kind: StatementKind::Trigger {
+                                        entity,
+                                        duration: beat_duration,
+                                    },
+                                    value: val,
+                                    indent: dot_token.indent,
+                                    line: dot_token.line,
+                                    column: dot_token.column,
+                                };
+                            }
+                        }
+                    }
 
-                    // Try to parse optional value (ex: .kick 250 params)
-                    match parser.peek_clone() {
+                    // fallback: simple numeric duration
+                    let duration = parse_duration(numerator);
+
+                    let val = match parser.peek_clone() {
                         Some(param_token) if param_token.kind == TokenKind::Identifier => {
                             parser.advance();
-                            (
-                                parse_duration(duration_lexeme),
-                                Value::Identifier(param_token.lexeme.clone()),
-                            )
+                            Value::Identifier(param_token.lexeme.clone())
                         }
-
                         Some(param_token) if param_token.kind == TokenKind::LBrace => {
-                            // Handle value as Map
-                            let map = parser.parse_map_value(); // Assumes you have a helper for map
-                            (parse_duration(duration_lexeme), map.unwrap_or(Value::Null))
+                            parser.parse_map_value().unwrap_or(Value::Null)
                         }
+                        _ => Value::Null,
+                    };
 
-                        _ => (parse_duration(duration_lexeme), Value::Null),
-                    }
+                    (duration, val)
                 }
 
                 TokenKind::Identifier => {
                     let duration_lexeme = token.lexeme.clone();
                     parser.advance(); // consume duration
 
-                    // Try to parse optional value (ex: .kick auto params)
-                    match parser.peek_clone() {
+                    let val = match parser.peek_clone() {
                         Some(param_token) if param_token.kind == TokenKind::Identifier => {
                             parser.advance();
-                            (
-                                parse_duration(duration_lexeme),
-                                Value::Identifier(param_token.lexeme.clone()),
-                            )
+                            Value::Identifier(param_token.lexeme.clone())
                         }
-
                         Some(param_token) if param_token.kind == TokenKind::LBrace => {
-                            // Handle value as Map
-                            let map = parser.parse_map_value(); // Assumes you have a helper for map
-                            (parse_duration(duration_lexeme), map.unwrap_or(Value::Null))
+                            parser.parse_map_value().unwrap_or(Value::Null)
                         }
+                        _ => Value::Null,
+                    };
 
-                        _ => (parse_duration(duration_lexeme), Value::Null),
-                    }
+                    (parse_duration(duration_lexeme), val)
                 }
 
                 _ => (Duration::Auto, Value::Null),
@@ -104,8 +169,8 @@ pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
 fn parse_duration(s: String) -> Duration {
     if s == "auto" {
         Duration::Auto
-    } else if s.parse::<f32>().is_ok() {
-        Duration::Number(s.parse().unwrap())
+    } else if let Ok(num) = s.parse::<f32>() {
+        Duration::Number(num)
     } else {
         Duration::Identifier(s)
     }

package/rust/core/preprocessor/loader.rs

@@ -1,10 +1,11 @@
-use std::{ collections::HashMap, path::Path };
+use std::{ collections::{ HashMap, HashSet }, path::Path };
 use crate::{
     core::{
         error::ErrorHandler,
         lexer::{ token::Token, Lexer },
-        parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+        parser::{ driver::Parser, statement::{ Statement, StatementKind } },
         preprocessor::{ module::Module, processor::process_modules },
+        shared::{ bank::BankFile, value::Value },
         store::global::GlobalStore,
         utils::path::normalize_path,
     },
@@ -86,15 +87,20 @@ impl ModuleLoader {
         let statements = parser.parse_tokens(tokens, global_store);
         module.statements = statements;
 
+        // SECTION Injecting bank triggers if any
+        if let Err(e) = self.inject_bank_triggers(&mut module, "808") {
+            return Err(format!("Failed to inject bank triggers: {}", e));
+        }
+
+        global_store.modules.insert(self.entry.clone(), module.clone());
+
         // SECTION Error handling
         let mut error_handler = ErrorHandler::new();
         error_handler.detect_from_statements(&mut parser, &module.statements);
 
-        global_store.modules.insert(self.entry.clone(), module.clone());
-
         Ok(module)
     }
-    
+
     pub fn load_wasm_module(&self, global_store: &mut GlobalStore) -> Result<(), String> {
         // Step one : Load the module from the global store
         let module = {
@@ -170,6 +176,23 @@ impl ModuleLoader {
 
         let statements = parser.parse_tokens(tokens.clone(), global_store);
 
+        // Insert module into store
+        let mut module = Module::new(&path);
+        module.tokens = tokens.clone();
+        module.statements = statements.clone();
+
+        // Inject triggers for each bank used in module
+        for bank_name in ModuleLoader::extract_bank_names(&statements) {
+            if let Err(e) = self.inject_bank_triggers(&mut module, &bank_name) {
+                return HashMap::new(); // Return empty map on error
+            }
+        }
+
+        global_store.insert_module(path.clone(), module);
+
+        // Load dependencies
+        self.load_module_imports(&path, global_store);
+
         // Error handling
         let mut error_handler = ErrorHandler::new();
         error_handler.detect_from_statements(&mut parser, &statements);
@@ -182,15 +205,6 @@ impl ModuleLoader {
             }
         }
 
-        // Insert module into store
-        let mut module = Module::new(&path);
-        module.tokens = tokens.clone();
-        module.statements = statements.clone();
-        global_store.insert_module(path.clone(), module);
-
-        // Load dependencies
-        self.load_module_imports(&path, global_store);
-
         // Return tokens per module
         global_store.modules
             .iter()
@@ -226,4 +240,69 @@ impl ModuleLoader {
             self.load_module_recursively(&resolved, global_store);
         }
     }
+
+    pub fn inject_bank_triggers(&self, module: &mut Module, bank_name: &str) -> Result<(), String> {
+        let bank_path = Path::new("./.deva/bank").join(bank_name);
+        let bank_file_path = bank_path.join("bank.toml");
+
+        if !bank_file_path.exists() {
+            return Ok(()); // Pas d'erreur si la banque n'existe pas encore
+        }
+
+        let content = std::fs
+            ::read_to_string(&bank_file_path)
+            .map_err(|e| format!("Failed to read '{}': {}", bank_file_path.display(), e))?;
+
+        let parsed: BankFile = toml
+            ::from_str(&content)
+            .map_err(|e| format!("Failed to parse '{}': {}", bank_file_path.display(), e))?;
+
+        let mut bank_map = HashMap::new();
+
+        for bank_trigger in parsed.triggers.unwrap_or_default() {
+            let trigger_name = bank_trigger.name.clone().replace("./", "");
+            let bank_trigger_path = format!("devalang://bank/{}/{}", bank_name, trigger_name);
+
+            bank_map.insert(bank_trigger.name.clone(), Value::String(bank_trigger_path.clone()));
+
+            if module.variable_table.variables.contains_key(bank_name) {
+                eprintln!(
+                    "⚠️ Trigger '{}' already defined in module '{}', skipping injection.",
+                    bank_name, module.path
+                );
+                continue;
+            }
+
+            module.variable_table.set(
+                format!("{}.{}", bank_name, bank_trigger.name),
+                Value::String(bank_trigger_path.clone())
+            );
+        }
+
+        // Inject the map under the bank name
+        module.variable_table.set(bank_name.to_string(), Value::Map(bank_map));
+
+        Ok(())
+    }
+
+    fn extract_bank_names(statements: &[Statement]) -> HashSet<String> {
+        let mut banks = HashSet::new();
+
+        for stmt in statements {
+            if let StatementKind::Trigger { entity, .. } = &stmt.kind {
+                let parts: Vec<&str> = entity.split('.').collect();
+                if parts.len() >= 2 {
+                    banks.insert(parts[0].to_string()); // "808.kick" → "808"
+                }
+            }
+
+            if let StatementKind::Bank = &stmt.kind {
+                if let Value::String(name) = &stmt.value {
+                    banks.insert(name.clone());
+                }
+            }
+        }
+
+        banks
+    }
 }

package/rust/core/preprocessor/resolver/driver.rs

@@ -73,6 +73,11 @@ fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore)
             Value::Null
         }
 
+        Value::Beat(beat_str) => {
+            println!("[warn] '{:?}': unresolved beat '{}'", module.path, beat_str);
+            Value::Beat(beat_str.clone())
+        }
+
         Value::Map(map) => {
             let mut resolved = HashMap::new();
             for (k, v) in map {

package/rust/core/shared/bank.rs

@@ -0,0 +1,21 @@
+use serde::{ Deserialize, Serialize };
+
+#[derive(Debug, Deserialize)]
+pub struct BankInfo {
+    pub name: String,
+    pub version: String,
+    pub description: String,
+    pub author: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BankFile {
+    pub bank: BankInfo,
+    pub triggers: Option<Vec<BankTrigger>>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BankTrigger {
+    pub name: String,
+    pub path: String,
+}

package/rust/core/shared/duration.rs

@@ -4,5 +4,6 @@ use serde::{ Deserialize, Serialize };
 pub enum Duration {
     Number(f32),
     Identifier(String),
+    Beat(String),
     Auto,
 }

package/rust/core/shared/mod.rs

@@ -1,2 +1,3 @@
 pub mod value;
-pub mod duration;
+pub mod duration;
+pub mod bank;

package/rust/core/shared/value.rs

@@ -13,6 +13,7 @@ pub enum Value {
     Map(HashMap<String, Value>),
     Block(Vec<Statement>),
     Sample(String),
+    Beat(String),
     Unknown,
     Null,
 }

package/rust/installer/bank.rs

@@ -0,0 +1,55 @@
+use std::path::{ Path, PathBuf };
+use crate::{
+    common::cdn::get_cdn_url,
+    config::loader::{ add_bank_to_config, load_config },
+    installer::utils::{ download_file, extract_archive },
+};
+
+pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
+    let cdn_url = get_cdn_url();
+    let url = format!("{}/bank/{}", cdn_url, name);
+
+    let bank_dir = target_dir.join("bank");
+    let archive_path = PathBuf::from(format!("./.deva/tmp/{}.devabank", name));
+    let extract_path = bank_dir.join(name);
+
+    if extract_path.exists() {
+        println!(
+            "Bank '{}' already exists at '{}'. Skipping install.",
+            name,
+            extract_path.display()
+        );
+        return Ok(());
+    }
+
+    download_file(&url, &archive_path).await.map_err(|e| format!("Failed to download: {}", e))?;
+
+    extract_archive(&archive_path, &extract_path).await.map_err(|e|
+        format!("Failed to extract: {}", e)
+    )?;
+
+    // Add the bank to the config
+    let root_dir = target_dir
+        .parent()
+        .ok_or_else(|| "Failed to determine root directory".to_string())?;
+
+    let config_path = root_dir.join(".devalang");
+    if !config_path.exists() {
+        return Err(
+            format!(
+                "Config file not found at '{}'. Please run 'devalang init' before adding an addon",
+                config_path.display()
+            )
+        );
+    }
+
+    let mut config = load_config(Some(&config_path)).ok_or_else(||
+        format!("Failed to load config from '{}'", config_path.display())
+    )?;
+
+    let dependency_path = &format!("devalang://bank/{}", name);
+
+    add_bank_to_config(&mut config, &extract_path, &dependency_path);
+
+    Ok(())
+}

package/rust/installer/mod.rs

@@ -0,0 +1,2 @@
+pub mod bank;
+pub mod utils;

package/rust/installer/utils.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/main.rs

@@ -4,24 +4,33 @@ pub mod core;
 pub mod cli;
 pub mod utils;
 pub mod config;
+pub mod common;
+pub mod installer;
 
 use std::io;
-use cli::{ Cli };
 use clap::Parser;
 use crate::{
     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 },
-        Commands,
-        TemplateCommand,
+        update::handle_update_command,
     },
-    config::{ loader::load_config, Config },
+    config::{ driver::Config, loader::load_config },
 };
 
-fn main() -> io::Result<()> {
+#[tokio::main]
+async fn main() -> io::Result<()> {
     let cli: Cli = Cli::parse();
     let mut config: Option<Config> = None;
 
@@ -58,6 +67,54 @@ fn main() -> io::Result<()> {
             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);
+            }
+        }
+
         _ => {}
     }