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

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 },
+    utils::installer::{ 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 @@
+pub mod bank;

package/rust/lib.rs

@@ -1,6 +1,7 @@
 pub mod core;
 pub mod utils;
 pub mod config;
+pub mod common;
 
 use serde::{ Deserialize, Serialize };
 use wasm_bindgen::prelude::*;

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);
+            }
+        }
+
         _ => {}
     }
 

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/mod.rs

@@ -3,4 +3,5 @@ pub mod signature;
 pub mod spinner;
 pub mod watcher;
 pub mod file;
-pub mod logger;
+pub mod logger;
+pub mod installer;

package/docs/COMMANDS.md

@@ -1,85 +0,0 @@
-<div align="center">
-    <img src="https://firebasestorage.googleapis.com/v0/b/devaloop-labs.firebasestorage.app/o/devalang-teal-logo.svg?alt=media&token=d2a5705a-1eba-4b49-88e6-895a761fb7f7" alt="Devalang Logo">
-</div>
-
-# Devalang Commands Guide
-
-## Initialization
-
-Initialize a new Devalang project (current folder)
-
-```bash
-devalang init
-```
-
-Initialize a new Devalang project (new folder)
-
-```bash
-devalang init --name <project-name> --template <template-name>
-```
-
-Available arguments:
-
-- `--name`: The name of the project (cannot be empty)
-- `--template`: The template to use for the project (default to `welcome`)
-
-## Checking
-
-Checking syntax of .deva file(s)
-
-```bash
-devalang check --entry ./examples --output ./output --watch
-```
-
-Available arguments :
-
-- `--no-config`: Whether to ignore the configuration file (default to `false`)
-- `--entry`: The input folder (default to `./src`)
-- `--output`: The output folder (default to `./output`)
-- `--watch`: Whether to watch for changes and re-analyze (default to `false`)
-
-## Building
-
-Building AST of .deva file(s)
-
-```bash
-devalang build --entry ./examples --output ./output --watch
-```
-
-Available arguments :
-
-- `--no-config`: Whether to ignore the configuration file (default to `false`)
-- `--entry`: The input folder (default to `./src`)
-- `--output`: The output folder (default to `./output`)
-- `--watch`: Whether to watch for changes and rebuild (default to `false`)
-
-
-## Playing
-
-Playing .deva file(s) without audio playback (once)
-
-```bash
-devalang play --entry ./examples --output ./output
-```
-
-Playing .deva file(s) with audio playback (once by file change)
-
-```bash
-devalang play --entry ./examples --output ./output --watch
-```
-
-Playing .deva file(s) with audio playback (infinite loop)
-
-```bash
-devalang play --entry ./examples --output ./output --repeat
-```
-
-Note : You cannot use `--watch` and `--repeat` options together. Use `--repeat` instead.
-
-Available arguments :
-
-- `--no-config`: Whether to ignore the configuration file (default to `false`)
-- `--entry`: The input folder (default to `./src`)
-- `--output`: The output folder (default to `./output`)
-- `--watch`: Whether to watch for changes and rebuild + play (default to `false`)
-- `--repeat`: Whether to repeat the playback of the audio file (default to `false`)

package/docs/CONFIG.md

@@ -1,30 +0,0 @@
-<div align="center">
-    <img src="https://firebasestorage.googleapis.com/v0/b/devaloop-labs.firebasestorage.app/o/devalang-teal-logo.svg?alt=media&token=d2a5705a-1eba-4b49-88e6-895a761fb7f7" alt="Devalang Logo">
-</div>
-
-# Devalang Configuration File
-
-Use a configuration file if you don't want to pass command-line arguments every time you run a command. The configuration file allows you to set default values for various settings, making it easier to manage your Devalang project.
-
-## Ignoring the Configuration File
-
-If you prefer not to use a configuration file, you can ignore it by passing the `--no-config` flag when running Devalang commands. This will bypass any settings defined in the configuration file and use only the command-line arguments you provide.
-
-## Structure of the Configuration File
-
-The configuration file is a TOML (Tom's Obvious, Minimal Language) file that contains key-value pairs to define various settings for your Devalang project. Below is a sample configuration file:
-
-```toml
-[defaults]
-entry = "./src"
-output = "./output"
-watch = false
-repeat = true
-```
-
-### Available Settings
-
-- `entry`: (String) The entry point for your Devalang project (default to `./src`)
-- `output`: (String) The output directory for generated files (default to `./output`)
-- `watch`: (Boolean) Whether to watch for changes in files and automatically rebuild or check them (default to `false`)
-- `repeat`: (Boolean) Whether to repeat the playback of audio files (default to `false`)