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

package/rust/cli/bank.rs

@@ -1,6 +1,6 @@
 use std::fs;
 
-use serde::{ Deserialize, Serialize };
+use serde::Deserialize;
 use crate::{
     common::cdn::get_cdn_url,
     config::loader::{ load_config, remove_bank_from_config, update_bank_version_in_config },
@@ -102,7 +102,7 @@ pub async fn handle_update_bank_command(name: Option<String>) -> Result<(), Stri
             );
         }
 
-        let mut config = load_config(Some(&config_path)).ok_or_else(||
+        let config = load_config(Some(&config_path)).ok_or_else(||
             format!("Failed to load config from '{}'", config_path.display())
         )?;
 
@@ -255,8 +255,8 @@ pub async fn handle_remove_bank_command(name: String) -> Result<(), String> {
 pub async fn handle_bank_available_command() -> Result<(), String> {
     let bank_list = match list_external_banks().await {
         Ok(list) => list,
-        Err(err) => {
-            eprintln!("❌ Error fetching bank list: {}", err);
+    Err(_err) => {
+            eprintln!("❌ Error fetching bank list");
             return Err("Failed to fetch bank list".into());
         }
     };
@@ -283,7 +283,7 @@ pub async fn handle_bank_info_command(
 
     let response = match reqwest::get(&url).await {
         Ok(resp) => resp,
-        Err(err) => {
+    Err(_err) => {
             return Err("Failed to fetch bank info".into());
         }
     };
@@ -294,8 +294,8 @@ pub async fn handle_bank_info_command(
 
     let bytes = match response.bytes().await {
         Ok(b) => b,
-        Err(err) => {
-            eprintln!("❌ Error reading response body: {}", err);
+    Err(_err) => {
+            eprintln!("❌ Error reading response body");
             return Err("Failed to read response body".into());
         }
     };
@@ -314,8 +314,8 @@ pub async fn handle_bank_info_command(
 pub async fn handle_bank_list_command() -> Result<(), String> {
     let bank_list = match list_installed_banks().await {
         Ok(list) => list,
-        Err(err) => {
-            eprintln!("❌ Error fetching bank list: {}", err);
+    Err(_err) => {
+            eprintln!("❌ Error fetching bank list");
             return Err("Failed to fetch bank list".into());
         }
     };
@@ -325,11 +325,10 @@ pub async fn handle_bank_list_command() -> Result<(), String> {
     for bank_toml in bank_list {
         let latest_version = match fetch_latest_version(bank_toml.bank.name.clone()).await {
             Ok(version) => version,
-            Err(err) => {
+        Err(_err) => {
                 eprintln!(
-                    "❌ Error fetching latest version for '{}': {}",
-                    bank_toml.bank.name,
-                    err
+                    "❌ Error fetching latest version for '{}'",
+                    bank_toml.bank.name
                 );
                 continue;
             }
@@ -398,6 +397,7 @@ async fn list_installed_banks() -> Result<Vec<BankFile>, String> {
         return Ok(banks); // No banks installed
     }
 
+    // TODO: Verify installed banks in files
     // let installed_banks = std::fs
     //     ::read_dir(bank_dir)
     //     .map_err(|e| format!("Failed to read bank directory: {}", e))?;
@@ -416,7 +416,7 @@ async fn list_installed_banks() -> Result<Vec<BankFile>, String> {
         );
     }
 
-    let mut config = load_config(Some(&config_path)).ok_or_else(||
+    let config = load_config(Some(&config_path)).ok_or_else(||
         format!("Failed to load config from '{}'", config_path.display())
     )?;
 
@@ -440,8 +440,8 @@ async fn list_installed_banks() -> Result<Vec<BankFile>, String> {
 
                     match toml::from_str::<BankFile>(&content) {
                         Ok(bank_info) => banks.push(bank_info),
-                        Err(err) => {
-                            eprintln!("❌ Error parsing bank info for '{}': {}", bank_name, err);
+                        Err(_err) => {
+                            eprintln!("❌ Error parsing bank info for '{}'", bank_name);
                         }
                     }
                 } else {

package/rust/cli/build.rs

@@ -21,7 +21,9 @@ pub fn handle_build_command(
     config: Option<Config>,
     entry: Option<String>,
     output: Option<String>,
-    watch: bool
+    watch: bool,
+    debug: bool,
+    compress: bool
 ) {
     let fetched_entry = if entry.is_none() {
         config
@@ -77,7 +79,7 @@ pub fn handle_build_command(
 
     // SECTION Begin build
     if fetched_watch {
-        begin_build(entry_file.clone(), fetched_output.clone());
+        begin_build(entry_file.clone(), fetched_output.clone(), debug, compress);
 
         logger.log_message(
             LogLevel::Watcher,
@@ -87,14 +89,14 @@ pub fn handle_build_command(
         watch_directory(entry_file.clone(), move || {
             logger.log_message(LogLevel::Watcher, "Detected changes, re-building...");
 
-            begin_build(entry_file.clone(), fetched_output.clone());
+            begin_build(entry_file.clone(), fetched_output.clone(), debug, compress);
         }).unwrap();
     } else {
-        begin_build(entry_file.clone(), fetched_output.clone());
+        begin_build(entry_file.clone(), fetched_output.clone(), debug, compress);
     }
 }
 
-fn begin_build(entry: String, output: String) {
+fn begin_build(entry: String, output: String, debug: bool, compress: bool) {
     let spinner = with_spinner("Building...", || {
         thread::sleep(Duration::from_millis(800));
     });
@@ -112,49 +114,86 @@ fn begin_build(entry: String, output: String) {
     let (modules_tokens, modules_statements) = module_loader.load_all_modules(&mut global_store);
 
     // SECTION Write logs
-    for (module_path, module) in global_store.modules.clone() {
-        write_module_variable_log_file(
+    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,
-            &module_path,
-            &module.variable_table
+            "resolved_statements.log",
+            modules_statements.clone()
         );
-        write_module_function_log_file(
+        write_variables_log_file(
             &normalized_output_dir,
-            &module_path,
-            &module.function_table
+            "global_variables.log",
+            global_store.variables.clone()
+        );
+        write_function_log_file(
+            &normalized_output_dir,
+            "global_functions.log",
+            global_store.functions.clone()
         );
     }
 
-    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, &normalized_output_dir);
+    builder.build_ast(&modules_statements, &normalized_output_dir, compress);
     builder.build_audio(&modules_statements, &normalized_output_dir, &mut global_store);
 
     // SECTION Logging
     let logger = Logger::new();
 
+    if debug {
+        let modules_loaded = global_store.modules
+            .iter()
+            .map(|(k, _)| k)
+            .collect::<Vec<_>>();
+        let global_variables_loaded = global_store.variables.variables.keys().collect::<Vec<_>>();
+        let global_functions_loaded = global_store.functions.functions.keys().collect::<Vec<_>>();
+
+        logger.log_message_with_trace(
+            LogLevel::Debug,
+            &format!("Modules loaded: {}", global_store.modules.len()),
+            modules_loaded
+                .iter()
+                .map(|s| s.as_str())
+                .collect()
+        );
+        logger.log_message_with_trace(
+            LogLevel::Debug,
+            &format!("Global variables: {}", global_store.variables.variables.len()),
+            global_variables_loaded
+                .iter()
+                .map(|s| s.as_str())
+                .collect()
+        );
+        logger.log_message_with_trace(
+            LogLevel::Debug,
+            &format!("Global functions: {}", global_store.functions.functions.len()),
+            global_functions_loaded
+                .iter()
+                .map(|s| s.as_str())
+                .collect()
+        );
+    }
+
     let success_message = format!(
         "Build completed successfully in {:.2?}. Output files written to: '{}'",
         duration.elapsed(),
         normalized_output_dir
     );
 
+    spinner.finish_and_clear();
     logger.log_message(LogLevel::Success, &success_message);
 }

package/rust/cli/check.rs

@@ -1,12 +1,18 @@
 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::{
-        collect_errors_recursively,
+        error::collect_errors_recursively,
         logger::{ LogLevel, Logger },
         spinner::with_spinner,
         watcher::watch_directory,
@@ -19,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
@@ -75,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,
@@ -85,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));
     });
@@ -116,6 +123,38 @@ fn begin_check(entry: String, output: String) {
         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));
@@ -136,5 +175,6 @@ fn begin_check(entry: String, output: String) {
         normalized_output_dir
     );
 
+    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;