@devaloop/devalang 0.0.1-alpha.16-hotfix.1 → 0.0.1-alpha.17

package/rust/types/src/ast.rs

@@ -0,0 +1,198 @@
+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,
+
+    // ───── 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,74 @@
+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>,
+}
+
+#[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,12 @@
+//! Common shared types for Devalang
+
+pub mod addons;
+pub mod ast;
+pub mod config;
+pub mod telemetry;
+
+// Re-exports for convenience
+pub use addons::*;
+pub use ast::*;
+pub use config::*;
+pub use telemetry::*;

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,23 @@
+[package]
+name = "devalang_utils"
+version = "0.0.1"
+edition = "2024"
+
+[dependencies]
+devalang_types = { path = "../types" }
+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"]