@devaloop/devalang 0.0.1-alpha.1

package/out-tsc/scripts/version/sync.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncVersion = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const syncVersion = (projectVersionPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const version = fs_1.default.readFileSync(projectVersionPath, "utf-8").trim();
+    const versionString = JSON.parse(version).version;
+    // Package.json
+    const pkgPath = path_1.default.join(__dirname, "..", "..", "..", "package.json");
+    const pkgJson = JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"));
+    pkgJson.version = versionString;
+    fs_1.default.writeFileSync(pkgPath, JSON.stringify(pkgJson, null, 2));
+    // Cargo.toml
+    const cargoPath = path_1.default.join(__dirname, "..", "..", "..", "Cargo.toml");
+    const cargoToml = fs_1.default.readFileSync(cargoPath, "utf-8");
+    const updatedCargo = cargoToml.replace(/(version\s*=\s*")[^"]*(")/, `$1${versionString}$2`);
+    fs_1.default.writeFileSync(cargoPath, updatedCargo);
+});
+exports.syncVersion = syncVersion;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@devaloop/devalang",
+  "private": false,
+  "version": "0.0.1-alpha.1",
+  "description": "Write music like code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text.",
+  "main": "out-tsc/index.js",
+  "bin": {
+    "devalang": "./out-tsc/bin/index.js"
+  },
+  "scripts": {
+    "prepublish": "cargo build --release && npm run script:postbuild",
+    "rust:dev": "cargo run",
+    "rust:dev:build": "cargo run build --entry examples --output output",
+    "rust:dev:check": "cargo run check --entry examples --output output",
+    "script:postbuild": "tsc && node out-tsc/scripts/postbuild.js",
+    "script:version:bump": "tsc && node out-tsc/scripts/version/index.js"
+  },
+  "homepage": "https://devaloop.com",
+  "keywords": [
+    "devalang",
+    "music",
+    "sound",
+    "domain-specific language",
+    "dsl",
+    "programming language",
+    "sound design",
+    "music hacking",
+    "audio",
+    "synthesis",
+    "scripting",
+    "sound synthesis",
+    "music programming"
+  ],
+  "author": "Devaloop",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/devaloop-labs/devalang.git"
+  },
+  "dependencies": {
+    "@types/node": "^24.0.3"
+  }
+}

package/project-version.json

@@ -0,0 +1,6 @@
+{
+  "version": "0.0.1-alpha.1",
+  "channel": "alpha",
+  "lastCommit": "",
+  "build": 1
+}

package/rust/audio/mod.rs

@@ -0,0 +1 @@
+// TODO Audio engine

package/rust/cli/build.rs

@@ -0,0 +1,51 @@
+use std::{ thread, time::Duration };
+
+use crate::{
+    core::{
+        builder::{ build_ast, write_ast_to_file },
+        debugger::Debugger,
+        preprocessor::module::load_all_modules,
+    },
+    runner::executer::execute_statements,
+    utils::{ loader::with_spinner, logger::log_message, path::{ find_entry_file, normalize_path } },
+};
+
+pub fn handle_build_command(entry: String, output: String) {
+    let entry_file = find_entry_file(&entry).unwrap_or_else(|| {
+        eprintln!("❌ index.deva not found in directory: {}", entry);
+        std::process::exit(1);
+    });
+
+    let spinner = with_spinner("Building...", || {
+        thread::sleep(Duration::from_millis(800));
+    });
+
+    let duration = std::time::Instant::now();
+
+    let normalized_entry_file = normalize_path(&entry_file);
+    let normalized_output_dir = normalize_path(&output);
+
+    let global_store = load_all_modules(&normalized_entry_file);
+
+    if let Some(module) = global_store.modules.get(&normalized_entry_file) {
+        let mut module_clone = module.clone();
+
+        let resolved_statements = execute_statements(&mut module_clone);
+
+        let ast = build_ast(&resolved_statements);
+
+        let ast_dir = format!("{}/json", normalized_output_dir.clone());
+        write_ast_to_file(&ast, &ast_dir);
+
+        let debugger = Debugger::new(&module_clone);
+        let debug_dir = format!("{}/debug/", normalized_output_dir.clone());
+        debugger.write_files(debug_dir.as_str(), resolved_statements);
+
+        let success_message = format!(
+            "Build completed successfully in {:.2?}. Output files written to: '{}'",
+            duration.elapsed(),
+            normalized_output_dir
+        );
+        log_message(&success_message, "SUCCESS");
+    }
+}

package/rust/cli/check.rs

@@ -0,0 +1,124 @@
+use std::{ thread, time::Duration };
+
+use crate::{
+    core::{
+        debugger::Debugger,
+        preprocessor::module::load_all_modules,
+        types::{
+            statement::{
+                Statement,
+                StatementIterator,
+                StatementKind,
+                StatementResolved,
+                StatementResolvedValue,
+            },
+            variable::VariableValue,
+        },
+    },
+    runner::executer::execute_statements,
+    utils::{ loader::with_spinner, logger::log_message, path::{ find_entry_file, normalize_path } },
+};
+
+pub fn handle_check_command(entry: String, output: String) -> () {
+    let entry_file = find_entry_file(&entry).unwrap_or_else(|| {
+        eprintln!("❌ index.deva not found in directory: {}", entry);
+        std::process::exit(1);
+    });
+
+    let spinner = with_spinner("Checking...", || {
+        thread::sleep(Duration::from_millis(800));
+    });
+
+    let duration = std::time::Instant::now();
+
+    let normalized_entry_file = normalize_path(&entry_file);
+    let normalized_output_dir = normalize_path(&output);
+
+    let global_store = load_all_modules(&normalized_entry_file);
+
+    if let Some(module) = global_store.modules.get(&normalized_entry_file) {
+        let mut module_clone = module.clone();
+
+        let resolved_statements = execute_statements(&mut module_clone);
+
+        let debugger = Debugger::new(&module_clone);
+        let debug_dir = format!("{}/debug/", normalized_output_dir.clone());
+        debugger.write_files(debug_dir.as_str(), resolved_statements.clone());
+
+        let has_errors = resolved_statements.iter().any(|stmt| {
+            match_error_recursively_resolved(&stmt.clone())
+        });
+
+        if has_errors {
+            let warning_message = format!(
+                "Check completed with errors in {:.2?}. Output files written to: '{}'",
+                duration.elapsed(),
+                normalized_output_dir
+            );
+
+            log_message(&warning_message, "WARNING");
+        } else {
+            let success_message = format!(
+                "Check completed successfully in {:.2?}. Output files written to: '{}'",
+                duration.elapsed(),
+                normalized_output_dir
+            );
+
+            log_message(&success_message, "SUCCESS");
+        }
+    }
+}
+
+fn match_error_recursively_resolved(stmt: &StatementResolved) -> bool {
+    match stmt.value.clone() {
+        // TODO Other statement value types here
+
+        StatementResolvedValue::Map(map) => {
+            for (key, value) in map {
+                if match_error_recursively_resolved_value(&value) {
+                    return true;
+                }
+            }
+        }
+
+        StatementResolvedValue::Array(array) => {
+            for item in array {
+                if match_error_recursively_resolved(&item) {
+                    return true;
+                }
+            }
+        }
+
+        _ => {
+            if let StatementKind::Error = stmt.kind {
+                eprintln!("❌ Error found in statement: {:?}", stmt);
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
+fn match_error_recursively_resolved_value(value: &StatementResolvedValue) -> bool {
+    match value {
+        StatementResolvedValue::Map(map) => {
+            for (_, v) in map {
+                if match_error_recursively_resolved_value(v) {
+                    return true;
+                }
+            }
+        }
+        
+        StatementResolvedValue::Array(array) => {
+            for item in array {
+                if match_error_recursively_resolved(item) {
+                    return true;
+                }
+            }
+        }
+        _ => {}
+    }
+
+    false
+}

package/rust/cli/mod.rs

@@ -0,0 +1,3 @@
+pub mod check;
+pub mod new;
+pub mod build;

package/rust/cli/new.rs

@@ -0,0 +1 @@
+// TODO Implement the new command to create a new project with a template

package/rust/core/builder/mod.rs

@@ -0,0 +1,37 @@
+use crate::core::types::statement::{ StatementResolved };
+use std::fs::File;
+use std::io::Write;
+
+pub fn build_ast(statements: &Vec<StatementResolved>) -> String {
+    let mut ast_string = String::new();
+
+    serde_json
+        ::to_string_pretty(statements)
+        .map(|json| {
+            ast_string.push_str(&json);
+        })
+        .unwrap_or_else(|err| {
+            eprintln!("Error serializing AST: {}", err);
+            std::process::exit(1);
+        });
+
+    ast_string
+}
+
+pub fn write_ast_to_file(ast: &str, file_path: &str) {
+    clear_json_directory(&file_path);
+    create_json_directory(&file_path);
+
+    let file_path = format!("{}/ast.json", file_path);
+
+    let mut file = File::create(&file_path).expect("Unable to create AST file");
+    file.write_all(ast.as_bytes()).expect("Unable to write AST to file");
+}
+
+fn clear_json_directory(path: &str) {
+    std::fs::remove_dir_all(path);
+}
+
+fn create_json_directory(path: &str) {
+    std::fs::create_dir_all(path);
+}

package/rust/core/debugger/mod.rs

@@ -0,0 +1,57 @@
+use crate::core::types::{ module::Module, statement::{ StatementResolved } };
+
+pub struct Debugger {
+    pub module: Module,
+}
+
+impl Debugger {
+    pub fn new(module: &Module) -> Self {
+        Debugger {
+            module: module.clone(),
+        }
+    }
+
+    pub fn write_files(&self, output_dir: &str, resolved_statements: Vec<StatementResolved>) {
+        const LEXER_FILENAME: &str = "debug_lexer.log";
+        const STATEMENTS_FILENAME: &str = "debug_statements.log";
+
+        let lexer_path = format!("{}{}", output_dir, LEXER_FILENAME);
+        let statements_path = format!("{}{}", output_dir, STATEMENTS_FILENAME);
+
+        // Collect debug information
+        let tokens = self.module.tokens
+            .iter()
+            .map(|token| format!("{:?}", token))
+            .collect::<Vec<String>>();
+        let statements = resolved_statements
+            .iter()
+            .map(|stmt| format!("{:?}", stmt))
+            .collect::<Vec<String>>();
+
+        // Ensure the debug directory exists and is cleared
+        clear_debug_directory(output_dir);
+        create_debug_directory(output_dir);
+
+        // Writing files
+        write_tokens_debug_to_file(&tokens, &lexer_path);
+        write_statements_debug_to_file(&statements, &statements_path);
+    }
+}
+
+fn clear_debug_directory(path: &str) {
+    std::fs::remove_dir_all(path);
+}
+
+fn create_debug_directory(path: &str) {
+    std::fs::create_dir_all(path);
+}
+
+fn write_statements_debug_to_file(statements: &Vec<String>, path: &str) {
+    let content = statements.join("\n");
+    std::fs::write(path, content).expect("Unable to write statements to file");
+}
+
+fn write_tokens_debug_to_file(tokens: &Vec<String>, path: &str) {
+    let content = tokens.join("\n");
+    std::fs::write(path, content).expect("Unable to write tokens to file");
+}

package/rust/core/lexer/mod.rs

@@ -0,0 +1,333 @@
+use crate::core::types::token::{ Token, TokenKind };
+
+pub fn lex(input: String) -> Vec<Token> {
+    let mut tokens = Vec::new();
+
+    let mut line = 1;
+    let mut column = 1;
+
+    let mut indent_stack: Vec<usize> = vec![0];
+    let mut current_indent = 0;
+    let mut at_line_start = true;
+
+    let mut chars = input.chars().peekable();
+
+    while let Some(_) = chars.peek() {
+        if at_line_start {
+            current_indent = 0;
+
+            while let Some(&c) = chars.peek() {
+                if c == ' ' {
+                    current_indent += 1;
+                    chars.next();
+                    column += 1;
+                } else {
+                    break;
+                }
+            }
+
+            let last_indent = *indent_stack.last().unwrap();
+            if current_indent > last_indent {
+                indent_stack.push(current_indent);
+                tokens.push(Token {
+                    kind: TokenKind::Indent,
+                    lexeme: String::new(),
+                    line,
+                    column,
+                    indent: current_indent,
+                });
+            } else {
+                while current_indent < *indent_stack.last().unwrap() {
+                    indent_stack.pop();
+                    tokens.push(Token {
+                        kind: TokenKind::Dedent,
+                        lexeme: String::new(),
+                        line,
+                        column,
+                        indent: current_indent,
+                    });
+                }
+            }
+
+            at_line_start = false;
+        }
+
+        let Some(ch) = chars.next() else {
+            break;
+        };
+
+        if ch == '\n' {
+            tokens.push(Token {
+                kind: TokenKind::Newline,
+                lexeme: ch.to_string(),
+                line,
+                column,
+                indent: current_indent,
+            });
+
+            line += 1;
+            column = 1;
+            at_line_start = true;
+
+            continue;
+        }
+
+        if ch == ' ' || ch == '\t' {
+            column += if ch == '\t' { 4 } else { 1 };
+            continue;
+        }
+
+        if ch == '#' {
+            let mut comment = String::new();
+            while let Some(&c) = chars.peek() {
+                if c == '\n' {
+                    break;
+                }
+                comment.push(c);
+                chars.next();
+                column += 1;
+            }
+            tokens.push(Token {
+                kind: TokenKind::Comment(comment.trim().to_string()),
+                lexeme: ch.to_string(),
+                line,
+                column,
+                indent: current_indent,
+            });
+            continue;
+        }
+
+        if ch == ':' {
+            tokens.push(Token {
+                kind: TokenKind::Colon,
+                lexeme: ch.to_string(),
+                line,
+                column,
+                indent: current_indent,
+            });
+            column += 1;
+            continue;
+        }
+
+        if ch == '=' {
+            if let Some('=') = chars.peek() {
+                chars.next();
+                tokens.push(Token {
+                    kind: TokenKind::DoubleEquals,
+                    lexeme: ch.to_string(),
+                    line,
+                    column,
+                    indent: current_indent,
+                });
+                column += 2;
+            } else {
+                tokens.push(Token {
+                    kind: TokenKind::Equals,
+                    lexeme: ch.to_string(),
+                    line,
+                    column,
+                    indent: current_indent,
+                });
+                column += 1;
+            }
+            continue;
+        }
+
+        if ch == '[' {
+            tokens.push(Token {
+                kind: TokenKind::LBracket,
+                lexeme: ch.to_string(),
+                line,
+                column,
+                indent: current_indent,
+            });
+            column += 1;
+            continue;
+        }
+
+        if ch == ']' {
+            tokens.push(Token {
+                kind: TokenKind::RBracket,
+                lexeme: ch.to_string(),
+                line,
+                column,
+                indent: current_indent,
+            });
+            column += 1;
+            continue;
+        }
+
+        if ch == '{' {
+            tokens.push(Token {
+                kind: TokenKind::LBrace,
+                lexeme: ch.to_string(),
+                line,
+                column,
+                indent: current_indent,
+            });
+            column += 1;
+            continue;
+        }
+
+        if ch == '}' {
+            tokens.push(Token {
+                kind: TokenKind::RBrace,
+                lexeme: ch.to_string(),
+                line,
+                column,
+                indent: current_indent,
+            });
+            column += 1;
+            continue;
+        }
+
+        if ch == '"' {
+            let mut string_content = String::new();
+            column += 1; // skip the opening quote
+
+            while let Some(next_ch) = chars.next() {
+                column += 1;
+                if next_ch == '"' {
+                    break; // closing quote reached
+                } else {
+                    string_content.push(next_ch);
+                }
+            }
+
+            tokens.push(Token {
+                kind: TokenKind::String,
+                lexeme: string_content,
+                line,
+                column,
+                indent: current_indent,
+            });
+
+            continue;
+        }
+
+        if ch == '\'' {
+            let mut string_content = String::new();
+            column += 1;
+
+            while let Some(next_ch) = chars.next() {
+                column += 1;
+                if next_ch == '\'' {
+                    break;
+                } else {
+                    string_content.push(next_ch);
+                }
+            }
+
+            tokens.push(Token {
+                kind: TokenKind::String,
+                lexeme: string_content,
+                line,
+                column,
+                indent: current_indent,
+            });
+
+            continue;
+        }
+
+        if ch == '.' {
+            tokens.push(Token {
+                kind: TokenKind::Dot,
+                lexeme: ch.to_string(),
+                line,
+                column,
+                indent: current_indent,
+            });
+            column += 1;
+            continue;
+        }
+
+        if ch == '@' {
+            tokens.push(Token {
+                kind: TokenKind::At,
+                lexeme: ch.to_string(),
+                line,
+                column,
+                indent: current_indent,
+            });
+            column += 1;
+            continue;
+        }
+
+        if ch.is_ascii_digit() {
+            let mut number = ch.to_string();
+            while let Some(&c) = chars.peek() {
+                if c.is_ascii_digit() {
+                    number.push(c);
+                    chars.next();
+                    column += 1;
+                } else {
+                    break;
+                }
+            }
+
+            // let value = number.parse::<f32>().unwrap();
+            tokens.push(Token {
+                kind: TokenKind::Number,
+                lexeme: number,
+                line,
+                column,
+                indent: current_indent,
+            });
+            continue;
+        }
+
+        if ch.is_ascii_alphabetic() {
+            let mut ident = ch.to_string();
+            while let Some(&c) = chars.peek() {
+                if c.is_ascii_alphanumeric() || c == '_' {
+                    ident.push(c);
+                    chars.next();
+                    column += 1;
+                } else {
+                    break;
+                }
+            }
+
+            let kind = match ident.as_str() {
+                "bank" => TokenKind::Bank,
+                "bpm" => TokenKind::Tempo,
+                "loop" => TokenKind::Loop,
+                _ => TokenKind::Identifier,
+            };
+
+            tokens.push(Token {
+                kind,
+                lexeme: ident,
+                line,
+                column,
+                indent: current_indent,
+            });
+            continue;
+        }
+
+        // Skip unknown char
+        column += 1;
+    }
+
+    while indent_stack.len() > 1 {
+        indent_stack.pop();
+        current_indent = *indent_stack.last().unwrap();
+        tokens.push(Token {
+            kind: TokenKind::Dedent,
+            lexeme: String::new(),
+            line,
+            column,
+            indent: current_indent,
+        });
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::EOF,
+        lexeme: String::new(),
+        line: line + 1, // EOF is considered to be on the next line
+        column: 0, // EOF has no column
+        indent: 0, // EOF has no indent
+    });
+
+    tokens
+}