@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-beta.1

package/rust/main.rs

@@ -1,65 +1,364 @@
-#![cfg(feature = "cli")]
-
-pub mod core;
-pub mod cli;
-pub mod utils;
-pub mod config;
-
-use std::io;
-use cli::{ Cli };
-use clap::Parser;
-use crate::{
-    cli::{
-        build::handle_build_command,
-        check::handle_check_command,
-        init::handle_init_command,
-        play::handle_play_command,
-        template::{ handle_template_info_command, handle_template_list_command },
-        Commands,
-        TemplateCommand,
-    },
-    config::{ loader::load_config, Config },
-};
-
-fn main() -> io::Result<()> {
-    let cli: Cli = Cli::parse();
-    let mut config: Option<Config> = None;
-
-    if !cli.no_config {
-        config = load_config(None);
-    } else {
-        println!("No configuration file loaded. Running with arguments only.");
-    }
-
-    match cli.command {
-        Commands::Init { name, template } => {
-            handle_init_command(name, template);
-        }
-
-        Commands::Template { command } =>
-            match command {
-                TemplateCommand::List => {
-                    handle_template_list_command();
-                }
-                TemplateCommand::Info { name } => {
-                    handle_template_info_command(name);
-                }
-            }
-
-        Commands::Check { entry, output, watch, compilation_mode, debug } => {
-            handle_check_command(config, entry, output, watch);
-        }
-
-        Commands::Build { entry, output, watch, compilation_mode, debug, compress } => {
-            handle_build_command(config, entry, output, watch);
-        }
-
-        Commands::Play { entry, output, watch, repeat } => {
-            handle_play_command(config, entry, output, watch, repeat);
-        }
-
-        _ => {}
-    }
-
-    Ok(())
-}
+#![cfg(feature = "cli")]
+
+pub mod cli;
+pub mod config;
+pub mod core;
+pub mod web;
+pub use devalang_utils as utils;
+use devalang_utils::path::ensure_deva_dir;
+
+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::commands::handle_build_command,
+        check::handle_check_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,
+    utils::first_usage::check_is_first_usage,
+};
+use clap::CommandFactory;
+use clap::FromArgMatches;
+use devalang_types::{AddonType, TelemetryErrorLevel};
+use std::io;
+
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    let version = devalang_utils::version::get_version();
+    let signature = devalang_utils::signature::get_signature(&version);
+
+    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(());
+    }
+
+    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 = config::ops::load_config(None);
+    } else {
+        println!("No configuration file loaded. Running with arguments only.");
+    }
+
+    match cli.command {
+        Commands::Init { name, template } => {
+            handle_init_command(name, template);
+        }
+
+        Commands::Template { command } => match command {
+            TemplateCommand::List => {
+                handle_template_list_command();
+            }
+            TemplateCommand::Info { name } => {
+                handle_template_info_command(name);
+            }
+        },
+
+        Commands::Check {
+            entry,
+            output,
+            watch,
+            debug,
+        } => {
+            if let Err(err) = handle_check_command(config, entry, output, watch, debug) {
+                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);
+            }
+        }
+
+        Commands::Build {
+            entry,
+            output,
+            watch,
+            debug,
+            compress,
+        } => {
+            if let Err(err) = handle_build_command(config, entry, output, watch, debug, compress) {
+                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);
+            }
+        }
+
+        Commands::Play {
+            entry,
+            output,
+            watch,
+            repeat,
+            debug,
+        } => {
+            if let Err(err) = handle_play_command(config, entry, output, watch, repeat, debug) {
+                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);
+            }
+        }
+
+        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 {
+                    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);
+                }
+            }
+            InstallCommand::Plugin { name } => {
+                if let Err(err) = handle_install_command(name, AddonType::Plugin).await {
+                    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);
+                }
+            }
+            InstallCommand::Preset { name } => {
+                if let Err(err) = handle_install_command(name, AddonType::Preset).await {
+                    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);
+                }
+            }
+        },
+
+        Commands::Bank { command } => match command {
+            BankCommand::List => {
+                if let Err(err) = handle_bank_list_command().await {
+                    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);
+                }
+            }
+
+            BankCommand::Available => {
+                if let Err(err) = handle_bank_available_command().await {
+                    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);
+                }
+            }
+
+            BankCommand::Info { name } => {
+                if let Err(err) = handle_bank_info_command(name).await {
+                    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);
+                }
+            }
+
+            BankCommand::Remove { name } => {
+                if let Err(err) = handle_remove_bank_command(name).await {
+                    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);
+                }
+            }
+
+            BankCommand::Update { name } => {
+                if let Err(err) = handle_update_bank_command(name).await {
+                    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);
+                }
+            }
+        },
+
+        Commands::Update { only } => {
+            if let Err(err) = handle_update_command(only).await {
+                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);
+            }
+        }
+
+        Commands::Telemetry { command } => match command {
+            TelemetryCommand::Enable { .. } => {
+                if let Err(err) = handle_telemetry_enable_command().await {
+                    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);
+                }
+            }
+            TelemetryCommand::Disable { .. } => {
+                if let Err(err) = handle_telemetry_disable_command().await {
+                    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);
+                }
+            }
+        },
+
+        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 {
+                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);
+            }
+        }
+
+        Commands::Logout { .. } => {
+            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);
+        }
+    }
+
+    // SECTION Telemetry
+    event.set_timestamp(chrono::Utc::now().to_string());
+    event.set_duration(duration.elapsed().as_millis() as u64);
+    event.set_success(!had_error);
+
+    if had_error {
+        event.set_error(TelemetryErrorLevel::Critical, last_error_message, exit_code);
+    }
+
+    let _ = send_telemetry_event(&event).await;
+
+    Ok(())
+}

package/rust/types/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "devalang_types"
+version = "0.0.2"
+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,
+        }
+    }
+}