@devaloop/devalang 0.0.1-alpha.13 → 0.0.1-alpha.15

package/rust/cli/play.rs

@@ -1,13 +1,11 @@
 use crate::{
-    core::{
+    config::driver::Config, core::{
         builder::Builder,
-        debugger::{ lexer::write_lexer_log_file, preprocessor::write_preprocessor_log_file },
+        debugger::{ lexer::write_lexer_log_file, module::{write_module_function_log_file, write_module_variable_log_file}, preprocessor::write_preprocessor_log_file, store::{write_function_log_file, write_variables_log_file} },
         preprocessor::loader::ModuleLoader,
         store::global::GlobalStore,
         utils::path::{ find_entry_file, normalize_path },
-    },
-    config::driver::Config,
-    utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner, watcher::watch_directory },
+    }, utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner, watcher::watch_directory }
 };
 
 use std::{ path::Path, sync::mpsc::channel, thread, time::Duration };
@@ -20,7 +18,8 @@ pub fn handle_play_command(
     entry: Option<String>,
     output: Option<String>,
     watch: bool,
-    repeat: bool
+    repeat: bool,
+    debug: bool
 ) {
     use crate::core::audio::player::AudioPlayer;
 
@@ -76,7 +75,7 @@ pub fn handle_play_command(
         });
 
         // Main thread: build + play in a loop
-        begin_play(&config, &entry_file, &output_path);
+        begin_play(&config, &entry_file, &output_path, debug);
         audio_player.play_file_once(&audio_file);
 
         logger.log_message(LogLevel::Watcher, "Watching for changes... Press Ctrl+C to exit.");
@@ -84,7 +83,7 @@ pub fn handle_play_command(
         while let Ok(_) = rx.recv() {
             logger.log_message(LogLevel::Watcher, "Change detected, rebuilding...");
 
-            begin_play(&config, &entry_file, &output_path);
+            begin_play(&config, &entry_file, &output_path, debug);
 
             logger.log_message(LogLevel::Info, "🎵 Playback started (once mode)...");
 
@@ -92,7 +91,7 @@ pub fn handle_play_command(
         }
     } else if fetched_repeat {
         // Initial build to start from a clean slate
-        begin_play(&config, &entry_file, &output_path);
+        begin_play(&config, &entry_file, &output_path, debug);
 
         logger.log_message(LogLevel::Info, "🎵 Playback started (repeat mode)...");
 
@@ -112,7 +111,7 @@ pub fn handle_play_command(
 
                 // Rebuild in a separate thread
                 std::thread::spawn(move || {
-                    begin_play(&config_clone, &entry_file, &output_path);
+                    begin_play(&config_clone, &entry_file, &output_path, debug);
                 });
 
                 last_snapshot = current_snapshot;
@@ -126,7 +125,7 @@ pub fn handle_play_command(
         }
     } else {
         // Single execution
-        begin_play(&config, &entry_file, &output_path);
+        begin_play(&config, &entry_file, &output_path, debug);
 
         logger.log_message(LogLevel::Info, "🎵 Playback started (once mode)...");
 
@@ -135,7 +134,7 @@ pub fn handle_play_command(
     }
 }
 
-fn begin_play(config: &Option<Config>, entry_file: &str, output: &str) {
+fn begin_play(_config: &Option<Config>, entry_file: &str, output: &str, debug: bool) {
     let spinner = with_spinner("Building...", || {
         thread::sleep(Duration::from_millis(800));
     });
@@ -149,16 +148,41 @@ fn begin_play(config: &Option<Config>, entry_file: &str, output: &str) {
     let (modules_tokens, modules_statements) = loader.load_all_modules(&mut global_store);
 
     // SECTION Write logs
-    write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
-    write_preprocessor_log_file(
-        &normalized_output_dir,
-        "resolved_statements.log",
-        modules_statements.clone()
-    );
+    if debug {
+        for (module_path, module) in global_store.modules.clone() {
+            write_module_variable_log_file(
+                &normalized_output_dir,
+                &module_path,
+                &module.variable_table
+            );
+            write_module_function_log_file(
+                &normalized_output_dir,
+                &module_path,
+                &module.function_table
+            );
+        }
+
+        write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
+        write_preprocessor_log_file(
+            &normalized_output_dir,
+            "resolved_statements.log",
+            modules_statements.clone()
+        );
+        write_variables_log_file(
+            &normalized_output_dir,
+            "global_variables.log",
+            global_store.variables.clone()
+        );
+        write_function_log_file(
+            &normalized_output_dir,
+            "global_functions.log",
+            global_store.functions.clone()
+        );
+    }
 
     // SECTION Building AST and Audio
     let builder = Builder::new();
-    builder.build_ast(&modules_statements, &output);
+    builder.build_ast(&modules_statements, &output, false);
     builder.build_audio(&modules_statements, &output, &mut global_store);
 
     // SECTION Logging
@@ -169,6 +193,7 @@ fn begin_play(config: &Option<Config>, entry_file: &str, output: &str) {
         normalized_output_dir
     );
 
+    spinner.finish_and_clear();
     logger.log_message(LogLevel::Success, &success_message);
 }
 

package/rust/cli/update.rs

@@ -1,4 +1,4 @@
-pub async fn handle_update_command(only: Option<String>) -> Result<(), Box<dyn std::error::Error>> {
+pub async fn handle_update_command(_only: Option<String>) -> Result<(), Box<dyn std::error::Error>> {
     println!("Updates are not yet implemented. This is a placeholder function.");
     Ok(())
 }

package/rust/common/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/common/cdn.rs

@@ -1,11 +1,5 @@
 pub fn get_cdn_url() -> String {
-    let cdn_url = std::env
-        ::var("CDN_URL")
-        .unwrap_or_else(|_| "https://cdn.devalang.com".to_string());
-
-    if !cdn_url.ends_with('/') {
-        format!("{}/", cdn_url)
-    } else {
-        cdn_url
-    }
+    let cdn_url = "https://cdn.devalang.com";
+    // let cdn_url = "http://127.0.0.1:8888";
+    cdn_url.to_string()
 }

package/rust/common/mod.rs

@@ -1 +1,3 @@
-pub mod cdn;
+pub mod cdn;
+pub mod api;
+pub mod sso;

package/rust/common/sso.rs

@@ -0,0 +1,5 @@
+pub fn get_sso_url() -> String {
+    let sso_url = "https://sso.devalang.com";
+    // let sso_url = "http://localhost:5174";
+    sso_url.to_string()
+}

package/rust/config/driver.rs

@@ -1,9 +1,12 @@
+use std::collections::HashMap;
+
 use serde::{ Deserialize, Serialize };
 
 #[derive(Debug, Deserialize, Clone, Serialize)]
 pub struct Config {
     pub defaults: ConfigDefaults,
     pub banks: Option<Vec<BankEntry>>,
+    pub plugins: Option<Vec<PluginEntry>>,
 }
 
 #[derive(Debug, Deserialize, Clone, Serialize)]
@@ -14,11 +17,24 @@ pub struct ConfigDefaults {
     pub repeat: Option<bool>,
 }
 
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct BankMetadata {
+    pub bank: HashMap<String, String>,
+    pub triggers: Option<Vec<HashMap<String, String>>>,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub struct BankEntry {
     pub path: String,
     pub version: Option<String>,
-    pub author: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub struct PluginEntry {
+    pub path: String,
+    pub version: String,
+    pub author: String,
+    pub access: String,
 }
 
 impl Config {
@@ -31,6 +47,7 @@ impl Config {
                 repeat: None,
             },
             banks: Some(Vec::new()),
+            plugins: Some(Vec::new()),
         }
     }
 
@@ -48,6 +65,7 @@ impl Config {
                 repeat,
             },
             banks: Some(Vec::new()),
+            plugins: Some(Vec::new()),
         }
     }
 

package/rust/config/loader.rs

@@ -1,6 +1,5 @@
 use std::{ fs, path::Path };
-use std::collections::HashMap;
-use crate::config::driver::{ BankEntry, Config };
+use crate::config::driver::{ BankEntry, BankMetadata, Config };
 
 pub fn load_config(path: Option<&Path>) -> Option<Config> {
     let config_path = path.unwrap_or_else(|| Path::new(".devalang"));
@@ -56,6 +55,59 @@ pub fn remove_bank_from_config(config: &mut Config, dependency: &str) {
     }
 }
 
+pub fn add_plugin_to_config(config: &mut Config, real_path: &Path, dependency: &str) {
+    if config.plugins.is_none() {
+        config.plugins = Some(Vec::new());
+    }
+
+    let plugins = config.plugins.as_mut().unwrap();
+
+    let exists = plugins.iter().any(|p| p.path == dependency);
+    if exists {
+        println!("Plugin '{}' already in config", dependency);
+        return;
+    }
+
+    let metadata_path = Path::new(real_path).join("plugin.toml");
+
+    if !metadata_path.exists() {
+        eprintln!("❌ Plugin metadata file '{}' does not exist", metadata_path.display());
+        return;
+    }
+
+    let metadata_content = std::fs
+        ::read_to_string(&metadata_path)
+        .expect("Failed to read plugin metadata file");
+
+    let metadata: std::collections::HashMap<String, String> = toml
+        ::from_str(&metadata_content)
+        .expect("Failed to parse plugin metadata file");
+
+    let plugin_entry = crate::config::driver::PluginEntry {
+        path: dependency.to_string(),
+        version: metadata
+            .get("version")
+            .cloned()
+            .unwrap_or_else(|| "0.0.1".to_string()),
+        author: metadata
+            .get("author")
+            .cloned()
+            .unwrap_or_else(|| "unknown".to_string()),
+        access: metadata
+            .get("access")
+            .cloned()
+            .unwrap_or_else(|| "public".to_string()),
+    };
+
+    plugins.push(plugin_entry);
+
+    if let Err(e) = config.write(config) {
+        eprintln!("❌ Failed to write config: {}", e);
+    } else {
+        println!("✅ Plugin '{}' added to config", dependency);
+    }
+}
+
 pub fn add_bank_to_config(config: &mut Config, real_path: &Path, dependency: &str) {
     if config.banks.is_none() {
         config.banks = Some(Vec::new());
@@ -80,24 +132,18 @@ pub fn add_bank_to_config(config: &mut Config, real_path: &Path, dependency: &st
         ::read_to_string(&metadata_path)
         .expect("Failed to read bank metadata file");
 
-    let metadata: HashMap<String, String> = toml
+    let metadata: BankMetadata = toml
         ::from_str(&metadata_content)
         .expect("Failed to parse bank metadata file");
 
     let bank_to_insert = BankEntry {
         path: dependency.to_string(),
         version: Some(
-            metadata
+            metadata.bank
                 .get("version")
                 .cloned()
                 .unwrap_or_else(|| "0.0.1".to_string())
         ),
-        author: Some(
-            metadata
-                .get("author")
-                .cloned()
-                .unwrap_or_else(|| "unknown".to_string())
-        ),
     };
 
     banks.push(bank_to_insert);