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

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,26 @@
+[package]
+name = "devalang_utils"
+version = "0.0.1"
+description = "Utility functions and types for Devalang"
+license = "MIT"
+authors = ["Devaloop <contact@devaloop.com>"]
+edition = "2024"
+
+[dependencies]
+devalang_types = { path = "../types", version = "0.0.1" }
+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"]

package/rust/utils/{error.rs → src/error.rs}

@@ -1,200 +1,186 @@
-use super::logger::{LogLevel, Logger};
-use crate::core::{
-    error::{ErrorResult, Severity, StackFrame},
-    parser::statement::{Statement, StatementKind},
-    shared::value::Value,
-};
-use std::collections::HashMap;
-
-/// Recursively collects errors from a list of statements.
-///
-/// This function traverses the provided statements and aggregates any
-/// `Unknown` or explicit `Error` statements into a flat vector.
-/// It also descends into loop bodies to ensure nested errors are
-/// surfaced.
-pub fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
-    let mut errors: Vec<ErrorResult> = Vec::new();
-
-    for stmt in statements {
-        match &stmt.kind {
-            StatementKind::Unknown => {
-                errors.push(ErrorResult {
-                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
-                    line: stmt.line,
-                    column: stmt.column,
-                    severity: Severity::Warning,
-                    stack: vec![StackFrame {
-                        module: None,
-                        context: Some("Unknown".to_string()),
-                        line: stmt.line,
-                        column: stmt.column,
-                    }],
-                });
-            }
-            StatementKind::Error { message } => {
-                errors.push(ErrorResult {
-                    message: message.clone(),
-                    line: stmt.line,
-                    column: stmt.column,
-                    severity: Severity::Critical,
-                    stack: vec![StackFrame {
-                        module: None,
-                        context: Some("Error".to_string()),
-                        line: stmt.line,
-                        column: stmt.column,
-                    }],
-                });
-            }
-            StatementKind::Loop => {
-                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
-                    let nested = collect_errors_recursively(body_statements);
-                    errors.extend(nested.into_iter().map(|mut e| {
-                        // push parent frame contextually for a basic callstack-like trace
-                        e.stack.insert(
-                            0,
-                            StackFrame {
-                                module: None,
-                                context: Some("loop".to_string()),
-                                line: stmt.line,
-                                column: stmt.column,
-                            },
-                        );
-                        e
-                    }));
-                }
-            }
-            _ => {}
-        }
-    }
-
-    errors
-}
-
-fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
-    if let Value::Map(map) = value {
-        if let Some(Value::Block(statements)) = map.get("body") {
-            return Some(statements);
-        }
-    }
-    None
-}
-
-pub fn partition_errors(errors: Vec<ErrorResult>) -> (Vec<ErrorResult>, Vec<ErrorResult>) {
-    let mut warnings = Vec::new();
-    let mut criticals = Vec::new();
-    for e in errors {
-        match e.severity {
-            Severity::Warning => warnings.push(e),
-            Severity::Critical => criticals.push(e),
-        }
-    }
-    (warnings, criticals)
-}
-
-pub fn log_errors_with_stack(prefix: &str, warnings: &[ErrorResult], criticals: &[ErrorResult]) {
-    let logger = Logger::new();
-    if !warnings.is_empty() {
-        logger.log_message(
-            LogLevel::Warning,
-            &format!("{}: {} warning(s)", prefix, warnings.len()),
-        );
-        for w in warnings {
-            logger.log_message(LogLevel::Warning, &format!("- {}", w.message));
-            // Print primary location in path:line:col if available
-            if let Some(frame) = w.stack.first() {
-                let module = frame.module.clone().unwrap_or_default();
-                logger.log_message(
-                    LogLevel::Debug,
-                    &format!(
-                        "     ↳ {}:{}:{} {}",
-                        module,
-                        frame.line,
-                        frame.column,
-                        frame.context.clone().unwrap_or_default()
-                    ),
-                );
-            }
-            // Print remaining frames if any
-            if w.stack.len() > 1 {
-                for (i, f) in w.stack.iter().enumerate().skip(1) {
-                    let module = f.module.clone().unwrap_or_default();
-                    logger.log_message(
-                        LogLevel::Debug,
-                        &format!(
-                            "       #{} {}:{}:{} {}",
-                            i,
-                            module,
-                            f.line,
-                            f.column,
-                            f.context.clone().unwrap_or_default()
-                        ),
-                    );
-                }
-            }
-        }
-    }
-    if !criticals.is_empty() {
-        logger.log_message(
-            LogLevel::Error,
-            &format!("{}: {} critical error(s)", prefix, criticals.len()),
-        );
-        for c in criticals {
-            logger.log_message(LogLevel::Error, &format!("- {}", c.message));
-            if let Some(frame) = c.stack.first() {
-                let module = frame.module.clone().unwrap_or_default();
-                logger.log_message(
-                    LogLevel::Error,
-                    &format!(
-                        "     ↳ {}:{}:{} {}",
-                        module,
-                        frame.line,
-                        frame.column,
-                        frame.context.clone().unwrap_or_default()
-                    ),
-                );
-            }
-            if c.stack.len() > 1 {
-                for (i, f) in c.stack.iter().enumerate().skip(1) {
-                    let module = f.module.clone().unwrap_or_default();
-                    logger.log_message(
-                        LogLevel::Error,
-                        &format!(
-                            "       #{} {}:{}:{} {}",
-                            i,
-                            module,
-                            f.line,
-                            f.column,
-                            f.context.clone().unwrap_or_default()
-                        ),
-                    );
-                }
-            }
-        }
-    }
-}
-
-pub fn collect_all_errors_with_modules(
-    modules: &HashMap<String, Vec<Statement>>,
-) -> Vec<ErrorResult> {
-    let mut all = Vec::new();
-    for (module_path, stmts) in modules {
-        let mut errs = collect_errors_recursively(stmts);
-        for e in errs.iter_mut() {
-            // ensure top frame carries the module path
-            if e.stack.is_empty() {
-                e.stack.push(StackFrame {
-                    module: Some(module_path.clone()),
-                    context: None,
-                    line: e.line,
-                    column: e.column,
-                });
-            } else {
-                if e.stack[0].module.is_none() {
-                    e.stack[0].module = Some(module_path.clone());
-                }
-            }
-        }
-        all.extend(errs);
-    }
-    all
-}
+use super::logger::{LogLevel, Logger};
+use devalang_types::{ErrorResult, Severity, StackFrame, Statement, StatementKind, Value};
+use std::collections::HashMap;
+
+pub fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                    severity: Severity::Warning,
+                    stack: vec![StackFrame {
+                        module: None,
+                        context: Some("Unknown".to_string()),
+                        line: stmt.line,
+                        column: stmt.column,
+                    }],
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                    severity: Severity::Critical,
+                    stack: vec![StackFrame {
+                        module: None,
+                        context: Some("Error".to_string()),
+                        line: stmt.line,
+                        column: stmt.column,
+                    }],
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    let nested = collect_errors_recursively(body_statements);
+                    errors.extend(nested.into_iter().map(|mut e| {
+                        e.stack.insert(
+                            0,
+                            StackFrame {
+                                module: None,
+                                context: Some("loop".to_string()),
+                                line: stmt.line,
+                                column: stmt.column,
+                            },
+                        );
+                        e
+                    }));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}
+
+pub fn partition_errors(errors: Vec<ErrorResult>) -> (Vec<ErrorResult>, Vec<ErrorResult>) {
+    let mut warnings = Vec::new();
+    let mut criticals = Vec::new();
+    for e in errors {
+        match e.severity {
+            Severity::Warning => warnings.push(e),
+            Severity::Critical => criticals.push(e),
+        }
+    }
+    (warnings, criticals)
+}
+
+pub fn log_errors_with_stack(prefix: &str, warnings: &[ErrorResult], criticals: &[ErrorResult]) {
+    let logger = Logger::new();
+    if !warnings.is_empty() {
+        logger.log_message(
+            LogLevel::Warning,
+            &format!("{}: {} warning(s)", prefix, warnings.len()),
+        );
+        for w in warnings {
+            logger.log_message(LogLevel::Warning, &format!("- {}", w.message));
+            if let Some(frame) = w.stack.first() {
+                let module = frame.module.clone().unwrap_or_default();
+                logger.log_message(
+                    LogLevel::Debug,
+                    &format!(
+                        "     ↳ {}:{}:{} {}",
+                        module,
+                        frame.line,
+                        frame.column,
+                        frame.context.clone().unwrap_or_default()
+                    ),
+                );
+            }
+            if w.stack.len() > 1 {
+                for (i, f) in w.stack.iter().enumerate().skip(1) {
+                    let module = f.module.clone().unwrap_or_default();
+                    logger.log_message(
+                        LogLevel::Debug,
+                        &format!(
+                            "       #{} {}:{}:{} {}",
+                            i,
+                            module,
+                            f.line,
+                            f.column,
+                            f.context.clone().unwrap_or_default()
+                        ),
+                    );
+                }
+            }
+        }
+    }
+    if !criticals.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            &format!("{}: {} critical error(s)", prefix, criticals.len()),
+        );
+        for c in criticals {
+            logger.log_message(LogLevel::Error, &format!("- {}", c.message));
+            if let Some(frame) = c.stack.first() {
+                let module = frame.module.clone().unwrap_or_default();
+                logger.log_message(
+                    LogLevel::Error,
+                    &format!(
+                        "     ↳ {}:{}:{} {}",
+                        module,
+                        frame.line,
+                        frame.column,
+                        frame.context.clone().unwrap_or_default()
+                    ),
+                );
+            }
+            if c.stack.len() > 1 {
+                for (i, f) in c.stack.iter().enumerate().skip(1) {
+                    let module = f.module.clone().unwrap_or_default();
+                    logger.log_message(
+                        LogLevel::Error,
+                        &format!(
+                            "       #{} {}:{}:{} {}",
+                            i,
+                            module,
+                            f.line,
+                            f.column,
+                            f.context.clone().unwrap_or_default()
+                        ),
+                    );
+                }
+            }
+        }
+    }
+}
+
+pub fn collect_all_errors_with_modules(
+    modules: &HashMap<String, Vec<Statement>>,
+) -> Vec<ErrorResult> {
+    let mut all = Vec::new();
+    for (module_path, stmts) in modules {
+        let mut errs = collect_errors_recursively(stmts);
+        for e in errs.iter_mut() {
+            if e.stack.is_empty() {
+                e.stack.push(StackFrame {
+                    module: Some(module_path.clone()),
+                    context: None,
+                    line: e.line,
+                    column: e.column,
+                });
+            } else {
+                if e.stack[0].module.is_none() {
+                    e.stack[0].module = Some(module_path.clone());
+                }
+            }
+        }
+        all.extend(errs);
+    }
+    all
+}