@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/types/src/config.rs

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

@@ -1,15 +0,0 @@
-//! 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

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

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

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

@@ -1,26 +0,0 @@
-[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"]

package/rust/utils/src/error.rs

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

package/rust/utils/src/file.rs

@@ -1,94 +0,0 @@
-use include_dir::{Dir, DirEntry};
-use std::{fs, path::Path};
-
-pub fn copy_dir_recursive(dir: &Dir, target_root: &Path, base_path: &Path) {
-    for entry in dir.entries() {
-        match entry {
-            DirEntry::Dir(subdir) => {
-                copy_dir_recursive(subdir, target_root, base_path);
-            }
-            DirEntry::File(file) => {
-                // Compute the destination path relative to the provided base.
-                let rel_path = match file.path().strip_prefix(base_path) {
-                    Ok(p) => p.to_owned(),
-                    Err(_) => {
-                        eprintln!(
-                            "Warning: failed to compute relative path for {:?}, skipping",
-                            file.path()
-                        );
-                        continue;
-                    }
-                };
-
-                let dest_path = target_root.join(rel_path);
-
-                if let Some(parent) = dest_path.parent() {
-                    if let Err(e) = fs::create_dir_all(parent) {
-                        eprintln!(
-                            "Warning: failed to create directory {}: {}",
-                            parent.display(),
-                            e
-                        );
-                        continue;
-                    }
-                }
-
-                if let Err(e) = fs::write(&dest_path, file.contents()) {
-                    eprintln!("Warning: failed to write {}: {}", dest_path.display(), e);
-                    continue;
-                }
-            }
-        }
-    }
-}
-
-pub fn format_file_size(bytes: u64) -> String {
-    const KB: u64 = 1024;
-    const MB: u64 = 1024 * 1024;
-
-    if bytes >= MB {
-        format!("{:.2} Mb", (bytes as f64) / (MB as f64))
-    } else if bytes >= KB {
-        format!("{:.2} Kb", (bytes as f64) / (KB as f64))
-    } else {
-        format!("{} bytes", bytes)
-    }
-}
-
-pub fn extract_zip_safely(archive_path: &Path, dest: &Path) -> Result<(), String> {
-    let file = std::fs::File::open(archive_path)
-        .map_err(|e| format!("Failed to open archive {}: {}", archive_path.display(), e))?;
-    let mut archive = zip::ZipArchive::new(file)
-        .map_err(|e| format!("Failed to read archive {}: {}", archive_path.display(), e))?;
-
-    for i in 0..archive.len() {
-        let mut file = archive
-            .by_index(i)
-            .map_err(|e| format!("Failed to access archive entry {}: {}", i, e))?;
-
-        let enclosed = match file.enclosed_name() {
-            Some(path) => path.to_owned(),
-            None => {
-                continue;
-            }
-        };
-
-        let outpath = dest.join(enclosed);
-
-        if file.name().ends_with('/') || file.is_dir() {
-            std::fs::create_dir_all(&outpath)
-                .map_err(|e| format!("Failed to create dir {}: {}", outpath.display(), e))?;
-        } else {
-            if let Some(p) = outpath.parent() {
-                std::fs::create_dir_all(p)
-                    .map_err(|e| format!("Failed to create parent {}: {}", p.display(), e))?;
-            }
-            let mut outfile = std::fs::File::create(&outpath)
-                .map_err(|e| format!("Failed to create file {}: {}", outpath.display(), e))?;
-            std::io::copy(&mut file, &mut outfile)
-                .map_err(|e| format!("Failed to write file {}: {}", outpath.display(), e))?;
-        }
-    }
-
-    Ok(())
-}