@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

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,
+        }
+    }
+}

package/rust/types/src/config.rs

@@ -0,0 +1,84 @@
+use serde::{Deserialize, Serialize};
+use toml::Value as TomlValue;
+
+use crate::TelemetrySettings;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct PluginExport {
+    pub name: String,
+    pub kind: String,
+    /// Optional default value provided by the plugin manifest (keeps toml::Value to preserve types)
+    #[serde(default)]
+    pub default: Option<TomlValue>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct PluginInfo {
+    pub author: String,
+    pub name: String,
+    /// Optional version string when available from a plugin file
+    #[serde(default)]
+    pub version: Option<String>,
+    /// Optional human-friendly description
+    #[serde(default)]
+    pub description: Option<String>,
+    pub exports: Vec<PluginExport>,
+}
+
+// --- Config types (centralised) ------------------------------------------
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct ProjectConfig {
+    pub defaults: ProjectConfigDefaults,
+    pub banks: Option<Vec<ProjectConfigBankEntry>>,
+    pub plugins: Option<Vec<ProjectConfigPluginEntry>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct ProjectConfigDefaults {
+    pub entry: Option<String>,
+    pub output: Option<String>,
+    pub watch: Option<bool>,
+    pub repeat: Option<bool>,
+    pub debug: Option<bool>,
+    pub compress: Option<bool>,
+    pub sample_rate: Option<u32>,
+    /// Preferred audio format for exports (e.g. "wav16", "wav24", "wav32").
+    /// Stored as a string to avoid cross-crate enum coupling.
+    #[serde(default)]
+    pub audio_format: Option<String>,
+
+    /// Preferred output formats (e.g. ["wav", "mid"]).
+    /// Stored as a list of strings for flexibility and backwards compatibility.
+    #[serde(default)]
+    pub output_format: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct ProjectConfigBankEntry {
+    pub path: String,
+    pub version: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct ProjectConfigPluginEntry {
+    pub path: String,
+    pub version: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct PluginEntry {
+    pub path: String,
+    #[serde(default)]
+    pub version: String,
+    #[serde(default)]
+    pub author: String,
+    #[serde(default)]
+    pub access: String,
+}
+
+#[derive(Serialize, Deserialize, Default, Debug)]
+pub struct UserSettings {
+    pub session: String,
+    pub telemetry: TelemetrySettings,
+}

package/rust/types/src/lib.rs

@@ -0,0 +1,15 @@
+//! Common shared types for Devalang
+
+pub mod addons;
+pub mod ast;
+pub mod config;
+pub mod telemetry;
+pub mod store;
+pub mod plugin;
+
+// Re-exports for convenience
+pub use addons::*;
+pub use ast::*;
+pub use config::*;
+pub use telemetry::*;
+pub use store::*;

package/rust/types/src/plugin.rs

@@ -0,0 +1,20 @@
+use serde::{Deserialize, Serialize};
+use toml::Value as TomlValue;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct PluginExport {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub kind: String,
+    #[serde(default)]
+    pub default: Option<TomlValue>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct PluginInfo {
+    pub author: String,
+    pub name: String,
+    pub version: Option<String>,
+    pub description: Option<String>,
+    pub exports: Vec<PluginExport>,
+}

package/rust/types/src/store.rs

@@ -0,0 +1,139 @@
+use std::collections::HashMap;
+
+use crate::ast::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct VariableTable {
+    pub variables: HashMap<String, Value>,
+    pub parent: Option<Box<VariableTable>>,
+}
+
+impl VariableTable {
+    pub fn new() -> Self {
+        VariableTable {
+            variables: HashMap::new(),
+            parent: None,
+        }
+    }
+
+    pub fn set(&mut self, name: String, value: Value) {
+        self.variables.insert(name, value);
+    }
+
+    pub fn with_parent(parent: VariableTable) -> Self {
+        Self {
+            variables: HashMap::new(),
+            parent: Some(Box::new(parent)),
+        }
+    }
+
+    pub fn get(&self, name: &str) -> Option<&Value> {
+        if let Some(v) = self.variables.get(name) {
+            return Some(v);
+        }
+        let mut current = &self.parent;
+        while let Some(boxed) = current {
+            if let Some(v) = boxed.variables.get(name) {
+                return Some(v);
+            }
+            current = &boxed.parent;
+        }
+        None
+    }
+
+    pub fn remove(&mut self, name: &str) -> Option<Value> {
+        self.variables.remove(name)
+    }
+}
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ImportTable {
+    pub imports: HashMap<String, Value>,
+}
+
+impl ImportTable {
+    pub fn new() -> Self {
+        ImportTable {
+            imports: HashMap::new(),
+        }
+    }
+
+    pub fn add_import(&mut self, name: String, value: Value) {
+        self.imports.insert(name, value);
+    }
+
+    pub fn get_import(&self, name: &str) -> Option<&Value> {
+        self.imports.get(name)
+    }
+
+    pub fn remove_import(&mut self, name: &str) -> Option<Value> {
+        self.imports.remove(name)
+    }
+}
+
+use crate::ast::Statement;
+
+#[derive(Debug, Clone)]
+pub struct FunctionDef {
+    pub name: String,
+    pub parameters: Vec<String>,
+    pub body: Vec<Statement>,
+}
+
+#[derive(Debug, Clone)]
+pub struct FunctionTable {
+    pub functions: HashMap<String, FunctionDef>,
+}
+
+impl Default for FunctionTable {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl FunctionTable {
+    pub fn new() -> Self {
+        FunctionTable {
+            functions: HashMap::new(),
+        }
+    }
+
+    pub fn add_function(&mut self, function: FunctionDef) {
+        self.functions.insert(function.name.clone(), function);
+    }
+
+    pub fn get_function(&self, name: &str) -> Option<&FunctionDef> {
+        self.functions.get(name)
+    }
+
+    pub fn remove_function(&mut self, name: &str) -> Option<FunctionDef> {
+        self.functions.remove(name)
+    }
+}
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ExportTable {
+    pub exports: HashMap<String, Value>,
+}
+
+impl ExportTable {
+    pub fn new() -> Self {
+        ExportTable {
+            exports: HashMap::new(),
+        }
+    }
+
+    pub fn add_export(&mut self, name: String, value: Value) {
+        self.exports.insert(name, value);
+    }
+
+    pub fn get_export(&self, name: &str) -> Option<&Value> {
+        self.exports.get(name)
+    }
+
+    pub fn remove_export(&mut self, name: &str) -> Option<Value> {
+        self.exports.remove(name)
+    }
+}
+
+// GlobalStore lives in core to avoid cyclic dependencies (it references Module).

package/rust/types/src/telemetry.rs

@@ -0,0 +1,85 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
+pub enum TelemetryErrorLevel {
+    #[default]
+    None,
+    Warning,
+    Critical,
+}
+
+#[derive(Debug)]
+pub enum TelemetrySendError {
+    Http(String),
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
+pub struct TelemetryProjectInfo {
+    pub config: Option<TelemetryProjectInfoConfig>,
+    pub stats: Option<TelemetryProjectInfoStats>,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
+pub struct TelemetryProjectInfoStats {
+    pub counts: TelemetryProjectInfoStatsCounts,
+    pub features: TelemetryProjectInfoStatsFeatures,
+    pub audio: TelemetryProjectInfoStatsAudio,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
+pub struct TelemetryProjectInfoStatsCounts {
+    pub nb_files: usize,
+    pub nb_modules: usize,
+    pub nb_lines: usize,
+    pub nb_banks: usize,
+    pub nb_plugins: usize,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
+pub struct TelemetryProjectInfoStatsFeatures {
+    pub uses_imports: bool,
+    pub uses_functions: bool,
+    pub uses_groups: bool,
+    pub uses_automations: bool,
+    pub uses_loops: bool,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
+pub struct TelemetryProjectInfoStatsAudio {
+    pub avg_bpm: Option<u32>,
+    pub has_synths: bool,
+    pub has_samples: bool,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
+pub struct TelemetryProjectInfoConfig {
+    pub entry_defined: bool,
+    pub output_defined: bool,
+    pub watch_defined: bool,
+    pub repeat_defined: bool,
+    pub debug_defined: bool,
+    pub compress_defined: bool,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
+pub struct TelemetryEvent {
+    pub uuid: String,
+    pub cli_version: String,
+    pub os: String,
+    pub command: Vec<String>,
+    pub project_info: Option<TelemetryProjectInfo>,
+    pub error_level: TelemetryErrorLevel,
+    pub error_message: Option<String>,
+    pub exit_code: Option<i32>,
+    pub timestamp: String,
+    pub duration: u64,
+    pub success: bool,
+}
+
+#[derive(Serialize, Deserialize, Default, Debug)]
+pub struct TelemetrySettings {
+    pub uuid: String,
+    pub stats: bool,
+    pub level: String,
+    pub enabled: bool,
+}

package/rust/utils/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "devalang_utils"
+version = "0.0.2"
+description = "Utility functions and types for Devalang"
+license = "MIT"
+authors = ["Devaloop <contact@devaloop.com>"]
+edition = "2024"
+
+[dependencies]
+devalang_types = { path = "../types", version = "0.0.3" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+include_dir = "0.7"
+notify = "6.1"
+zip = "4.3.0"
+
+[dependencies.crossterm]
+version = "0.27"
+optional = true
+
+[dependencies.indicatif]
+version = "0.17"
+optional = true
+
+[features]
+cli = ["crossterm", "indicatif"]