@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

package/rust/main.rs

@@ -1,53 +1,84 @@
 #![cfg(feature = "cli")]
 
 pub mod cli;
-pub mod common;
 pub mod config;
 pub mod core;
-pub mod installer;
-pub mod utils;
+pub mod web;
+use devalang_utils::path::ensure_deva_dir;
+pub use devalang_utils as utils;
 
+use crate::cli::telemetry::send::send_telemetry_event;
+use crate::config::settings::ensure_user_config_file_exists;
+use crate::config::settings::write_user_config_file;
 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,
+        build::commands::handle_build_command,
         check::handle_check_command,
-        driver::{BankCommand, Cli, Commands, InstallCommand, TelemetryCommand, TemplateCommand},
-        init::handle_init_command,
-        install::handle_install_command,
-        login::handle_login_command,
-        play::handle_play_command,
-        telemetry::{handle_telemetry_disable_command, handle_telemetry_enable_command},
-        template::{handle_template_info_command, handle_template_list_command},
-        update::handle_update_command,
+        discover::commands::handle_discover_command,
+        init::commands::handle_init_command,
+        install::commands::handle_install_command,
+        login::commands::handle_login_command,
+        parser::{BankCommand, Cli, Commands, InstallCommand, TelemetryCommand, TemplateCommand},
+        play::commands::handle_play_command,
+        telemetry::{
+            commands::{handle_telemetry_disable_command, handle_telemetry_enable_command},
+            event_creator::{TelemetryEventCreator, TelemetryEventExt},
+        },
+        template::commands::{handle_template_info_command, handle_template_list_command},
+        update::commands::handle_update_command,
     },
-    config::{driver::ProjectConfig, loader::load_config},
-    installer::addon::AddonType,
-    utils::{first_usage::check_is_first_usage, telemetry::TelemetryEventCreator},
+    config::driver::ProjectConfig,
+    utils::first_usage::check_is_first_usage,
 };
-use clap::Parser;
+use clap::CommandFactory;
+use clap::FromArgMatches;
+use devalang_types::{AddonType, TelemetryErrorLevel};
 use std::io;
 
 #[tokio::main]
 async fn main() -> io::Result<()> {
-    let cli: Cli = Cli::parse();
-    let mut config: Option<ProjectConfig> = None;
+    let version = devalang_utils::version::get_version();
+    let signature = devalang_utils::signature::get_signature(&version);
 
-    let duration = std::time::Instant::now();
+    let version_static: &'static str = Box::leak(format!("v{}", version).into_boxed_str());
+    let signature_static: &'static str = Box::leak(signature.into_boxed_str());
+
+    let mut cmd = Cli::command();
+    cmd = cmd.version(version_static).before_help(signature_static);
+
+    let raw_args: Vec<String> = std::env::args().collect();
+    if raw_args.iter().any(|a| a == "--version" || a == "-V") {
+        println!("{}", signature_static);
+        return Ok(());
+    }
 
-    check_is_first_usage();
+    let matches = cmd.get_matches();
+    let cli: Cli = Cli::from_arg_matches(&matches).expect("failed to parse cli args");
+    let mut config: Option<ProjectConfig> = None;
 
     let telemetry_event_creator = TelemetryEventCreator::new();
     let mut event = telemetry_event_creator.get_base_event();
+
     let mut had_error: bool = false;
     let mut last_error_message: Option<String> = None;
     let mut exit_code: Option<i32> = None;
 
+    let _ = ensure_deva_dir();
+
+    if check_is_first_usage() == true {
+        write_user_config_file();
+    } else {
+        ensure_user_config_file_exists();
+    }
+
+    let duration = std::time::Instant::now();
+
     if !cli.no_config {
-        config = load_config(None);
+        config = config::ops::load_config(None);
     } else {
         println!("No configuration file loaded. Running with arguments only.");
     }
@@ -73,7 +104,11 @@ async fn main() -> io::Result<()> {
             debug,
         } => {
             if let Err(err) = handle_check_command(config, entry, output, watch, debug) {
-                eprintln!("❌ Check failed: {}", err);
+                let logger = devalang_utils::logger::Logger::new();
+                logger.log_message(
+                    devalang_utils::logger::LogLevel::Error,
+                    &format!("❌ Check failed: {}", err),
+                );
                 had_error = true;
                 last_error_message = Some(format!("check failed: {}", err));
                 exit_code = Some(1);
@@ -88,7 +123,11 @@ async fn main() -> io::Result<()> {
             compress,
         } => {
             if let Err(err) = handle_build_command(config, entry, output, watch, debug, compress) {
-                eprintln!("❌ Build failed: {}", err);
+                let logger = devalang_utils::logger::Logger::new();
+                logger.log_message(
+                    devalang_utils::logger::LogLevel::Error,
+                    &format!("❌ Build failed: {}", err),
+                );
                 had_error = true;
                 last_error_message = Some(format!("build failed: {}", err));
                 exit_code = Some(1);
@@ -103,7 +142,11 @@ async fn main() -> io::Result<()> {
             debug,
         } => {
             if let Err(err) = handle_play_command(config, entry, output, watch, repeat, debug) {
-                eprintln!("❌ Play failed: {}", err);
+                let logger = devalang_utils::logger::Logger::new();
+                logger.log_message(
+                    devalang_utils::logger::LogLevel::Error,
+                    &format!("❌ Play failed: {}", err),
+                );
                 had_error = true;
                 last_error_message = Some(format!("play failed: {}", err));
                 exit_code = Some(1);
@@ -111,9 +154,25 @@ async fn main() -> io::Result<()> {
         }
 
         Commands::Install { command } => match command {
+            InstallCommand::Template { name } => {
+                if let Err(err) = handle_install_command(name, AddonType::Template).await {
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to install template: {}", err),
+                    );
+                    had_error = true;
+                    last_error_message = Some(format!("install template failed: {}", err));
+                    exit_code = Some(1);
+                }
+            }
             InstallCommand::Bank { name } => {
                 if let Err(err) = handle_install_command(name, AddonType::Bank).await {
-                    eprintln!("❌ Failed to install bank: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to install bank: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("install bank failed: {}", err));
                     exit_code = Some(1);
@@ -121,7 +180,11 @@ async fn main() -> io::Result<()> {
             }
             InstallCommand::Plugin { name } => {
                 if let Err(err) = handle_install_command(name, AddonType::Plugin).await {
-                    eprintln!("❌ Failed to install plugin: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to install plugin: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("install plugin failed: {}", err));
                     exit_code = Some(1);
@@ -129,7 +192,11 @@ async fn main() -> io::Result<()> {
             }
             InstallCommand::Preset { name } => {
                 if let Err(err) = handle_install_command(name, AddonType::Preset).await {
-                    eprintln!("❌ Failed to install preset: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to install preset: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("install preset failed: {}", err));
                     exit_code = Some(1);
@@ -140,7 +207,11 @@ async fn main() -> io::Result<()> {
         Commands::Bank { command } => match command {
             BankCommand::List => {
                 if let Err(err) = handle_bank_list_command().await {
-                    eprintln!("❌ Failed to list local banks: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to list local banks: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("bank list failed: {}", err));
                     exit_code = Some(1);
@@ -149,7 +220,11 @@ async fn main() -> io::Result<()> {
 
             BankCommand::Available => {
                 if let Err(err) = handle_bank_available_command().await {
-                    eprintln!("❌ Failed to list available banks: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to list available banks: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("bank available failed: {}", err));
                     exit_code = Some(1);
@@ -158,7 +233,11 @@ async fn main() -> io::Result<()> {
 
             BankCommand::Info { name } => {
                 if let Err(err) = handle_bank_info_command(name).await {
-                    eprintln!("❌ Failed to get bank info: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to get bank info: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("bank info failed: {}", err));
                     exit_code = Some(1);
@@ -167,7 +246,11 @@ async fn main() -> io::Result<()> {
 
             BankCommand::Remove { name } => {
                 if let Err(err) = handle_remove_bank_command(name).await {
-                    eprintln!("❌ Failed to remove bank: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to remove bank: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("bank remove failed: {}", err));
                     exit_code = Some(1);
@@ -176,7 +259,11 @@ async fn main() -> io::Result<()> {
 
             BankCommand::Update { name } => {
                 if let Err(err) = handle_update_bank_command(name).await {
-                    eprintln!("❌ Failed to update bank: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to update bank: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("bank update failed: {}", err));
                     exit_code = Some(1);
@@ -186,7 +273,11 @@ async fn main() -> io::Result<()> {
 
         Commands::Update { only } => {
             if let Err(err) = handle_update_command(only).await {
-                eprintln!("❌ Update failed: {}", err);
+                let logger = devalang_utils::logger::Logger::new();
+                logger.log_message(
+                    devalang_utils::logger::LogLevel::Error,
+                    &format!("❌ Update failed: {}", err),
+                );
                 had_error = true;
                 last_error_message = Some(format!("update failed: {}", err));
                 exit_code = Some(1);
@@ -196,7 +287,11 @@ async fn main() -> io::Result<()> {
         Commands::Telemetry { command } => match command {
             TelemetryCommand::Enable { .. } => {
                 if let Err(err) = handle_telemetry_enable_command().await {
-                    eprintln!("❌ Failed to enable telemetry: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to enable telemetry: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("telemetry enable failed: {}", err));
                     exit_code = Some(1);
@@ -204,7 +299,11 @@ async fn main() -> io::Result<()> {
             }
             TelemetryCommand::Disable { .. } => {
                 if let Err(err) = handle_telemetry_disable_command().await {
-                    eprintln!("❌ Failed to disable telemetry: {}", err);
+                    let logger = devalang_utils::logger::Logger::new();
+                    logger.log_message(
+                        devalang_utils::logger::LogLevel::Error,
+                        &format!("❌ Failed to disable telemetry: {}", err),
+                    );
                     had_error = true;
                     last_error_message = Some(format!("telemetry disable failed: {}", err));
                     exit_code = Some(1);
@@ -212,9 +311,26 @@ async fn main() -> io::Result<()> {
             }
         },
 
+        Commands::Discover {} => {
+            if let Err(err) = handle_discover_command().await {
+                let logger = devalang_utils::logger::Logger::new();
+                logger.log_message(
+                    devalang_utils::logger::LogLevel::Error,
+                    &format!("❌ Failed to discover: {}", err),
+                );
+                had_error = true;
+                last_error_message = Some(format!("discover failed: {}", err));
+                exit_code = Some(1);
+            }
+        }
+
         Commands::Login { .. } => {
             if let Err(err) = handle_login_command().await {
-                eprintln!("❌ Login failed: {}", err);
+                let logger = devalang_utils::logger::Logger::new();
+                logger.log_message(
+                    devalang_utils::logger::LogLevel::Error,
+                    &format!("❌ Login failed: {}", err),
+                );
                 had_error = true;
                 last_error_message = Some(format!("login failed: {}", err));
                 exit_code = Some(1);
@@ -222,7 +338,11 @@ async fn main() -> io::Result<()> {
         }
 
         Commands::Logout { .. } => {
-            eprintln!("❌ Logout command is not implemented yet.");
+            let logger = devalang_utils::logger::Logger::new();
+            logger.log_message(
+                devalang_utils::logger::LogLevel::Error,
+                "❌ Logout command is not implemented yet.",
+            );
             had_error = true;
             last_error_message = Some("logout not implemented".to_string());
             exit_code = Some(1);
@@ -235,16 +355,10 @@ async fn main() -> io::Result<()> {
     event.set_success(!had_error);
 
     if had_error {
-        event.set_error(
-            utils::telemetry::TelemetryErrorLevel::Critical,
-            last_error_message,
-            exit_code,
-        );
+        event.set_error(TelemetryErrorLevel::Critical, last_error_message, exit_code);
     }
 
-    utils::telemetry::refresh_event_project_info(&mut event);
-
-    let _ = utils::telemetry::send_telemetry_event(&event).await;
+    let _ = send_telemetry_event(&event).await;
 
     Ok(())
 }

package/rust/types/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "devalang_types"
+version = "0.0.1"
+description = "Types and traits for Devalang"
+license = "MIT"
+authors = ["Devaloop <contact@devaloop.com>"]
+edition = "2024"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+toml = "0.8"

package/rust/types/src/addons.rs

@@ -0,0 +1,55 @@
+use serde::Deserialize;
+
+#[derive(Debug, Clone)]
+pub struct DiscoveredAddon {
+    pub path: std::path::PathBuf,
+    pub name: String,
+    pub extension: String,
+    pub addon_type: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct AddonWithMetadata {
+    pub name: String,
+    pub path: String,
+    pub addon_type: String,
+    pub metadata: AddonMetadata,
+}
+
+#[derive(Debug, Clone)]
+pub struct AddonMetadata {
+    pub name: String,
+    pub author: String,
+    pub version: String,
+    pub description: String,
+    pub access: String,
+}
+
+#[derive(Debug, Clone)]
+pub enum AddonType {
+    Bank,
+    Plugin,
+    Preset,
+    Template,
+}
+
+#[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>>,
+    pub audio_path: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BankTrigger {
+    pub name: String,
+    pub path: String,
+}

package/rust/types/src/ast.rs

@@ -0,0 +1,202 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Duration {
+    Number(f32),
+    Identifier(String),
+    Beat(String),
+    Auto,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub enum Severity {
+    Warning,
+    Critical,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub struct StackFrame {
+    pub module: Option<String>,
+    pub context: Option<String>,
+    pub line: usize,
+    pub column: usize,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct ErrorResult {
+    pub message: String,
+    pub line: usize,
+    pub column: usize,
+    pub severity: Severity,
+    pub stack: Vec<StackFrame>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub enum StatementKind {
+    // ───── Core Instructions ─────
+    Tempo,
+    Bank {
+        alias: Option<String>,
+    },
+    Print,
+    Load {
+        source: String,
+        alias: String,
+    },
+    Use {
+        name: String,
+        alias: Option<String>,
+    },
+    Let {
+        name: String,
+    },
+    Automate {
+        target: String,
+    },
+    ArrowCall {
+        target: String,
+        method: String,
+        args: Vec<Value>,
+    },
+    Function {
+        name: String,
+        parameters: Vec<String>,
+        body: Vec<Statement>,
+    },
+
+    // ───── Instruments ─────
+    Synth,
+
+    // ───── Playback / Scheduling ─────
+    Trigger {
+        entity: String,
+        duration: Duration,
+        effects: Option<Value>,
+    },
+    Sleep,
+    Call {
+        name: String,
+        args: Vec<Value>,
+    },
+    Spawn {
+        name: String,
+        args: Vec<Value>,
+    },
+    Loop,
+
+    // ───── Structure & Logic ─────
+    Group,
+    Pattern {
+        name: String,
+        target: Option<String>,
+    },
+
+    // ───── Module System ─────
+    Include(String),
+    Export {
+        names: Vec<String>,
+        source: String,
+    },
+    Import {
+        names: Vec<String>,
+        source: String,
+    },
+
+    // ───── Conditions ─────
+    If,
+    Else,
+    ElseIf,
+
+    // ───── Internal / Utility ─────
+    Comment,
+    Indent,
+    Dedent,
+    NewLine,
+
+    // ───── Events / Live coding ─────
+    On {
+        event: String,
+        args: Option<Vec<Value>>,
+        body: Vec<Statement>,
+    },
+    Emit {
+        event: String,
+        payload: Option<Value>,
+    },
+
+    // ───── Error Handling ─────
+    Unknown,
+    Error {
+        message: String,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Value {
+    Boolean(bool),
+    Number(f32),
+    Duration(Duration),
+    Identifier(String),
+    String(String),
+    Array(Vec<Value>),
+    Map(HashMap<String, Value>),
+    Block(Vec<Statement>),
+    Sample(String),
+    Beat(String),
+    Statement(Box<Statement>),
+    StatementKind(Box<StatementKind>),
+    Unknown,
+    Null,
+}
+
+impl Value {
+    pub fn get(&self, key: &str) -> Option<&Value> {
+        if let Value::Map(map) = self {
+            map.get(key)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Statement {
+    pub kind: StatementKind,
+    pub value: Value,
+    pub indent: usize,
+    pub line: usize,
+    pub column: usize,
+}
+
+impl Statement {
+    pub fn unknown() -> Self {
+        Statement {
+            kind: StatementKind::Unknown,
+            value: Value::Null,
+            indent: 0,
+            line: 0,
+            column: 0,
+        }
+    }
+
+    pub fn unknown_with_pos(indent: usize, line: usize, column: usize) -> Self {
+        Statement {
+            kind: StatementKind::Unknown,
+            value: Value::Null,
+            indent,
+            line,
+            column,
+        }
+    }
+
+    pub fn error_with_pos(indent: usize, line: usize, column: usize, message: String) -> Self {
+        Statement {
+            kind: StatementKind::Error { message },
+            value: Value::Null,
+            indent,
+            line,
+            column,
+        }
+    }
+}