@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/main.rs

@@ -1,388 +0,0 @@
-#![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,
-            output_format,
-            audio_format,
-            sample_rate,
-        } => {
-            if let Err(err) = handle_build_command(
-                config,
-                entry,
-                output,
-                output_format,
-                audio_format,
-                sample_rate,
-                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,
-            sample_rate,
-            watch,
-            repeat,
-            debug,
-            audio_format,
-        } => {
-            if let Err(err) = handle_play_command(
-                config,
-                entry,
-                output,
-                audio_format,
-                sample_rate,
-                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

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

@@ -1,55 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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,
-        }
-    }
-}