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

package/rust/cli/check.rs

@@ -1,11 +1,22 @@
 use crate::{
     config::driver::Config,
     core::{
+        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 },
     },
-    utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner, watcher::watch_directory },
+    utils::{
+        collect_errors_recursively,
+        logger::{ LogLevel, Logger },
+        spinner::with_spinner,
+        watcher::watch_directory,
+    },
 };
 use std::{ thread, time::Duration };
 
@@ -14,7 +25,8 @@ pub fn handle_check_command(
     config: Option<Config>,
     entry: Option<String>,
     output: Option<String>,
-    watch: bool
+    watch: bool,
+    debug: bool
 ) {
     let fetched_entry = if entry.is_none() {
         config
@@ -70,7 +82,7 @@ pub fn handle_check_command(
 
     // SECTION Begin check
     if fetched_watch {
-        begin_check(entry_file.clone(), fetched_output.clone());
+        begin_check(entry_file.clone(), fetched_output.clone(), debug);
 
         logger.log_message(
             LogLevel::Watcher,
@@ -80,14 +92,14 @@ pub fn handle_check_command(
         watch_directory(entry_file.clone(), move || {
             logger.log_message(LogLevel::Watcher, "Detected changes, re-checking...");
 
-            begin_check(entry_file.clone(), fetched_output.clone());
+            begin_check(entry_file.clone(), fetched_output.clone(), debug);
         }).unwrap();
     } else {
-        begin_check(entry_file.clone(), fetched_output.clone());
+        begin_check(entry_file.clone(), fetched_output.clone(), debug);
     }
 }
 
-fn begin_check(entry: String, output: String) {
+fn begin_check(entry: String, output: String, debug: bool) {
     let spinner = with_spinner("Checking...", || {
         thread::sleep(Duration::from_millis(800));
     });
@@ -104,7 +116,58 @@ fn begin_check(entry: String, output: String) {
     // NOTE: We don't use modules in the check command, but we still need to load them
     let modules = module_loader.load_all_modules(&mut global_store);
 
-    // TODO: Implement debugging
+    // Debugging: Log loaded modules and errors
+    let logger = Logger::new();
+    logger.log_message(LogLevel::Info, "Loaded modules:");
+    for (module_name, _) in &modules.0 {
+        logger.log_message(LogLevel::Info, &format!("- {}", module_name));
+    }
+
+    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.0.clone());
+        write_preprocessor_log_file(
+            &normalized_output_dir,
+            "resolved_statements.log",
+            modules.1.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()
+        );
+    }
+
+    let mut all_errors = Vec::new();
+    for (_, statements) in &modules.1 {
+        all_errors.extend(collect_errors_recursively(statements));
+    }
+
+    if !all_errors.is_empty() {
+        logger.log_message(LogLevel::Error, "Errors detected during check:");
+        for error in all_errors {
+            logger.log_message(LogLevel::Error, &format!("- {}", error.message));
+        }
+    } else {
+        logger.log_message(LogLevel::Success, "No errors detected.");
+    }
 
     let success_message = format!(
         "Check completed successfully in {:.2?}. Output files written to: '{}'",
@@ -112,6 +175,6 @@ fn begin_check(entry: String, output: String) {
         normalized_output_dir
     );
 
-    let logger = Logger::new();
+    spinner.finish_and_clear();
     logger.log_message(LogLevel::Success, &success_message);
 }

package/rust/cli/driver.rs

@@ -21,6 +21,14 @@ pub enum InstallCommand {
     Bank {
         name: String,
     },
+    /// Installs a plugin.
+    Plugin {
+        name: String,
+    },
+    /// Installs a preset.
+    Preset {
+        name: String,
+    },
 }
 
 #[derive(Subcommand)]
@@ -103,10 +111,12 @@ pub enum Commands {
     /// - `entry` - The entry point of the program to build. Defaults to "./src".
     /// - `output` - The directory where the output files will be generated. Defaults to "./output".
     /// - `watch` - Whether to watch for changes and rebuild. Defaults to "true".
+    /// - `debug` - Whether to print debug information. Defaults to "false".
+    /// - `compress` - Whether to compress the output files. Defaults to "false".
     ///
     /// ### Example
     /// ```bash
-    /// devalang build --entry ./src --output ./output --watch true
+    /// devalang build --entry ./src --output ./output --watch true --debug false --compress false
     /// ```
     ///
     Build {
@@ -128,19 +138,6 @@ pub enum Commands {
         ///
         watch: bool,
 
-        #[arg(long, default_value = "real-time")]
-        /// The mode of compilation.
-        ///
-        /// ### Default value
-        /// - `real-time`
-        ///
-        /// ### Possible values
-        /// - `real-time` - Compiles files as soon as possible.
-        /// - `batch` - Compiles files one by one.
-        /// - `check` - Analyzes the code without compiling it.
-        ///
-        compilation_mode: String,
-
         #[arg(short, long, default_value_t = false)]
         /// Whether to print debug information.
         ///
@@ -164,9 +161,13 @@ pub enum Commands {
     /// - `entry` - The entry point of the program to analyze. Defaults to "./src".
     /// - `output` - The directory where the output files will be generated. Defaults to "./output".
     /// - `watch` - Whether to watch for changes and re-analyze. Defaults to "true".
-    /// - `compilation_mode` - The mode of compilation. Defaults to "real-time".
     /// - `debug` - Whether to print debug information. Defaults to "false".
     ///
+    /// ### Example
+    /// ```bash
+    /// devalang check --entry ./src --output ./output --watch true --debug false
+    /// ```
+    ///
     Check {
         #[arg(short, long)]
         /// The entry point of the program to analyze.
@@ -184,19 +185,6 @@ pub enum Commands {
         ///
         watch: bool,
 
-        #[arg(short, long, default_value = "real-time")]
-        /// The mode of compilation.
-        ///
-        /// ### Default value
-        /// - `real-time`
-        ///
-        /// ### Possible values
-        /// - `real-time` - Analyzes files as soon as possible.
-        /// - `batch` - Analyzes files one by one.
-        /// - `check` - Analyzes the code without compiling it.
-        ///
-        compilation_mode: String,
-
         #[arg(short, long, default_value_t = false)]
         /// Whether to print debug information.
         ///
@@ -213,6 +201,14 @@ pub enum Commands {
     /// - `output` - The directory where the output files will be generated. Defaults to "./output".
     /// - `watch` - Whether to watch for changes and re-play. Defaults to "false".
     /// - `repeat` - Whether to replay the program after it finishes. Defaults to "false".
+    /// - `debug` - Whether to print debug information. Defaults to "false".
+    ///
+    /// Note: `--repeat` and `--watch` cannot be used together. Instead use `repeat` to watch for changes and replay the program.
+    ///
+    /// ### Example
+    /// ```bash
+    /// devalang play --entry ./src --output ./output --repeat true --debug false
+    /// ```
     ///
     Play {
         #[arg(short, long)]
@@ -238,6 +234,14 @@ pub enum Commands {
         /// - `false`
         ///
         repeat: bool,
+
+        #[arg(short, long, default_value_t = false)]
+        /// Whether to print debug information.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        debug: bool,
     },
 
     /// Update the Devalang CLI to the latest version.
@@ -277,4 +281,12 @@ pub enum Commands {
         #[command(subcommand)]
         command: BankCommand,
     },
+
+    /// Log in to your Devaloop account.
+    ///
+    Login {},
+
+    /// Log out of your Devaloop account.
+    /// 
+    Logout {},
 }

package/rust/cli/install.rs

@@ -1,16 +1,31 @@
-use crate::installer::bank::install_bank;
+use crate::installer::addon::{ install_addon, AddonType };
 
+/// Handles the installation command for a given addon type and name.
 #[cfg(feature = "cli")]
-pub async fn handle_install_bank_command(name: String) -> Result<(), String> {
+pub async fn handle_install_command(name: String, addon_type: AddonType) -> Result<(), String> {
+    use crate::utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner };
+    use std::{ thread, time::Duration };
+
+    let logger = Logger::new();
     let deva_dir = std::path::Path::new("./.deva/");
 
-    println!("⬇️  Installing bank '{}'...", name);
-    println!("📂 Target directory: {}", deva_dir.display());
+    let spinner = with_spinner("Installing...", || {
+        thread::sleep(Duration::from_millis(800));
+    });
 
-    if let Err(e) = install_bank(name.as_str(), deva_dir).await {
-        eprintln!("❌ Error installing bank '{}': {}", name, e);
+    if let Err(e) = install_addon(addon_type.clone(), name.as_str(), deva_dir).await {
+        spinner.finish_and_clear();
+        logger.log_message_with_trace(
+            LogLevel::Error,
+            &format!("Error installing {:?} '{}'", addon_type, name),
+            vec![&e]
+        );
     } else {
-        println!("✅ Bank '{}' installed successfully!", name);
+        spinner.finish_and_clear();
+        logger.log_message(
+            LogLevel::Success,
+            &format!("{:?} '{}' installed successfully!", addon_type, name)
+        );
     }
 
     Ok(())

package/rust/cli/login.rs

@@ -0,0 +1,134 @@
+use std::fs;
+use tiny_http::{ Server, Response };
+use webbrowser;
+use serde::{ Serialize, Deserialize };
+use dirs::home_dir;
+use crate::common::sso::get_sso_url;
+use std::{ thread, time::Duration };
+use tiny_http::Header;
+use std::str::FromStr;
+
+#[derive(Serialize, Deserialize)]
+struct UserConfig {
+    token: String,
+}
+
+/// Handle the login command
+/// This function initiates the login process by opening the browser and waiting for the callback.
+#[cfg(feature = "cli")]
+pub async fn handle_login_command() -> Result<(), String> {
+    use crate::utils::spinner::with_spinner;
+    use crate::utils::logger::Logger;
+    use crate::utils::logger::LogLevel;
+
+    let logger = Logger::new();
+
+    let mut listener_port = 7878;
+
+    let test_port_already_in_use = format!("127.0.0.1:{}", listener_port);
+    while std::net::TcpListener::bind(&test_port_already_in_use).is_err() {
+        listener_port += 1;
+    }
+
+    let redirect_uri = format!("http://127.0.0.1:{}/callback", listener_port);
+    let login_url = format!(
+        "{}/?response_type=code&referer=cli&redirect_uri={}",
+        get_sso_url(),
+        redirect_uri
+    );
+
+    if webbrowser::open(&login_url).is_ok() {
+        logger.log_message(LogLevel::Info, "Opening browser for login...");
+        logger.log_message(
+            LogLevel::Info,
+            &format!("If the browser does not open, please visit the following URL: {}", login_url)
+        );
+    } else {
+        logger.log_message(
+            LogLevel::Info,
+            "Please open the following URL in your browser to login:"
+        );
+        logger.log_message(LogLevel::Info, &login_url);
+    }
+
+    let server = Server::http(format!("127.0.0.1:{}", listener_port)).unwrap();
+
+    let spinner = with_spinner("Waiting for authentication...", || {
+        thread::sleep(Duration::from_millis(800));
+    });
+
+    for request in server.incoming_requests() {
+        let query = request.url().to_string();
+        if request.url().starts_with("/callback") {
+            if query.contains("session=") || query.contains("error=") {
+                let token = query.split("session=").nth(1).unwrap_or("").to_string();
+
+                if token.len() > 0 {
+                    let response_html =
+                        r#"
+                        <html>
+                            <body>
+                                <h1>Authentication Successful</h1>
+                                <h2>You can now close this window.</h2>
+                            </body>
+                        </html>
+                    "#;
+
+                    let response = Response::from_string(response_html)
+                        .with_status_code(200)
+                        .with_header(Header::from_str("Content-Type: text/html").unwrap());
+
+                    request.respond(response).unwrap();
+
+                    save_token(&token);
+
+                    spinner.finish_and_clear();
+
+                    logger.log_message(
+                        LogLevel::Success,
+                        "Authentication successful. Token saved to ~/.devalang/session_token.json"
+                    );
+
+                    break;
+                } else {
+                    spinner.finish_and_clear();
+                    logger.log_message(LogLevel::Error, "Invalid session token.");
+                    request.respond(Response::from_string("Invalid session token.")).unwrap();
+
+                    break;
+                }
+            } else {
+                println!("Invalid callback: {}", request.url());
+
+                spinner.finish_and_clear();
+                logger.log_message(LogLevel::Error, "Invalid callback.");
+                request.respond(Response::from_string("Invalid callback.")).unwrap();
+
+                break;
+            }
+        } else if request.url().starts_with("/favicon.ico") {
+            // Ignore favicon requests
+        } else {
+            spinner.finish_and_clear();
+            logger.log_message(LogLevel::Error, "Invalid request.");
+            request.respond(Response::from_string("Invalid request.")).unwrap();
+
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+/// Save the session token to a file in the user's home directory
+fn save_token(token: &str) {
+    let config = UserConfig { token: token.to_string() };
+    let json = serde_json::to_string(&config).unwrap();
+
+    let mut path = home_dir().unwrap();
+    path.push(".devalang");
+    fs::create_dir_all(&path).unwrap();
+
+    path.push("session_token.json");
+    fs::write(path, json).unwrap();
+}

package/rust/cli/mod.rs

@@ -7,4 +7,5 @@ pub mod template;
 pub mod play;
 pub mod install;
 pub mod bank;
-pub mod update;
+pub mod update;
+pub mod login;

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,8 +125,8 @@ 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)...");
 
         audio_player.play_file_once(&audio_file);
@@ -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/common/api.rs

@@ -0,0 +1,8 @@
+pub fn get_api_url() -> String {
+    let api_url = std::env
+        ::var("API_URL")
+        .unwrap_or_else(|_| "https://api.devalang.com".to_string());
+        // .unwrap_or_else(|_| "http://127.0.0.1:8989".to_string());
+
+    api_url
+}

package/rust/common/cdn.rs

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

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,8 @@
+pub fn get_sso_url() -> String {
+    let sso_url = std::env
+        ::var("SSO_URL")
+        .unwrap_or_else(|_| "https://sso.devalang.com".to_string());
+        // .unwrap_or_else(|_| "http://localhost:5174".to_string());
+
+    sso_url
+}

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()),
         }
     }