@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.2

package/rust/core/types/cli.rs

@@ -7,6 +7,10 @@ use crate::utils::version::get_version;
 #[command(version = get_version())]
 #[command(about = "🦊 Devalang – A programming language for music and sound.")]
 pub struct Cli {
+    #[arg(long, global = true)]
+    /// Skips loading the configuration file.
+    pub no_config: bool,
+
     #[command(subcommand)]
     pub command: CliCommands,
 }
@@ -34,6 +38,36 @@ pub enum CompilationMode {
 
 #[derive(Subcommand)]
 pub enum CliCommands {
+    /// Create a new Devalang project.
+    ///
+    /// ### Arguments
+    /// - `name` - The name of the project to create.
+    /// - `template` - The template to use for the project. Defaults to "default".
+    ///
+    /// ### Example
+    /// ```bash
+    /// devalang init --name my_project --template default
+    ///
+    Init {
+        #[arg(short, long)]
+        /// The optional name (directory) of the project to create.
+        name: Option<String>,
+
+        #[arg(short, long)]
+        /// The template to use for the project.
+        ///
+        /// ### Default value
+        /// - `default`
+        ///
+        template: Option<String>,
+    },
+
+    Template {
+        #[command(subcommand)]
+        /// The template command to execute.
+        command: CliTemplateCommand,
+    },
+
     /// Build the program and generate output files.
     ///
     /// ### Arguments
@@ -47,29 +81,23 @@ pub enum CliCommands {
     /// ```
     ///
     Build {
-        #[arg(short, long, default_value = "./src")]
+        #[arg(short, long)]
         /// The entry point of the program to build.
         ///
-        /// ### Default value
-        /// - `./src`
-        ///
-        entry: String,
+        entry: Option<String>,
 
-        #[arg(short, long, default_value = "./output")]
+        #[arg(short, long)]
         /// The directory where the output files will be generated.
         ///
-        /// ### Default value
-        /// - `./output`
-        ///
-        output: String,
+        output: Option<String>,
 
-        #[arg(short, long, default_value = "true")]
+        #[arg(long, default_value_t = false)]
         /// Whether to watch for changes and rebuild.
         ///
         /// ### Default value
-        /// - `true`
+        /// - `false`
         ///
-        watch: String,
+        watch: bool,
 
         #[arg(long, default_value = "real-time")]
         /// The mode of compilation.
@@ -84,21 +112,21 @@ pub enum CliCommands {
         ///
         compilation_mode: String,
 
-        #[arg(short, long, default_value = "false")]
+        #[arg(short, long, default_value_t = false)]
         /// Whether to print debug information.
         ///
         /// ### Default value
         /// - `false`
         ///
-        debug: String,
+        debug: bool,
 
-        #[arg(short, long, default_value = "false")]
+        #[arg(short, long, default_value_t = false)]
         /// Whether to compress the output files.
         ///
         /// ### Default value
         /// - `false`
         ///
-        compress: String,
+        compress: bool,
     },
 
     /// Analyze the program for errors and warnings.
@@ -112,29 +140,23 @@ pub enum CliCommands {
     /// devalang check --entry ./src --watch true --compilation-mode real-time
     /// ```
     Check {
-        #[arg(short, long, default_value = "./src")]
+        #[arg(short, long)]
         /// The entry point of the program to analyze.
         ///
-        /// ### Default value
-        /// - `./src`
-        ///
-        entry: String,
+        entry: Option<String>,
 
-        #[arg(short, long, default_value = "./output")]
+        #[arg(short, long)]
         /// The directory where the output files will be generated.
         ///
-        /// ### Default value
-        /// - `./output`
-        ///
-        output: String,
+        output: Option<String>,
 
-        #[arg(short, long, default_value = "false")]
+        #[arg(long, default_value_t = false)]
         /// Whether to watch for changes and re-analyze.
         ///
         /// ### Default value
         /// - `false`
         ///
-        watch: String,
+        watch: bool,
 
         #[arg(short, long, default_value = "real-time")]
         /// The mode of compilation.
@@ -149,12 +171,12 @@ pub enum CliCommands {
         ///
         compilation_mode: String,
 
-        #[arg(short, long, default_value = "false")]
+        #[arg(short, long, default_value_t = false)]
         /// Whether to print debug information.
         ///
         /// ### Default value
         /// - `false`
         ///
-        debug: String,
+        debug: bool,
     },
 }

package/rust/core/types/config.rs

@@ -0,0 +1,15 @@
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct DevalangConfig {
+    pub defaults: Defaults,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Defaults {
+    pub entry: Option<String>,
+
+    pub output: Option<String>,
+
+    pub watch: Option<bool>,
+}

package/rust/core/types/mod.rs

@@ -4,4 +4,5 @@ pub mod variable;
 pub mod store;
 pub mod parser;
 pub mod module;
-pub mod cli;
+pub mod cli;
+pub mod config;

package/rust/main.rs

@@ -7,36 +7,47 @@ pub mod utils;
 use std::{ io };
 use clap::Parser;
 use crate::{
-    cli::{ build::handle_build_command, check::handle_check_command },
-    core::types::cli::{ Cli, CliCommands },
+    cli::{
+        build::handle_build_command,
+        check::handle_check_command,
+        init::handle_init_command,
+        template::{ handle_template_info_command, handle_template_list_command },
+    },
+    core::types::{ cli::{ Cli, CliCommands, CliTemplateCommand }, config::DevalangConfig },
+    utils::{ config::load_config, logger::log_message },
 };
 
 fn main() -> io::Result<()> {
-    let cli = Cli::parse();
+    let cli: Cli = Cli::parse();
+    let mut config: Option<DevalangConfig> = None;
+
+    if !cli.no_config {
+        config = load_config(None);
+    } else {
+        log_message("Configuration file loading is skipped.", "WARNING");
+    }
 
     match cli.command {
-        // TODO - Implement the new command
-        // CliCommands::New { name, template } => {
-        //     log_message("Command 'new project' is not implemented yet.", "WARNING");
-        // }
+        CliCommands::Init { name, template } => {
+            handle_init_command(name, template);
+        }
 
-        // TODO - Implement the template command
-        // CliCommands::Template { command } =>
-        //     match command {
-        //         CliTemplateCommand::List => {
-        //             log_message("Command 'template list' is not implemented yet.", "WARNING");
-        //         }
-        //         CliTemplateCommand::Info { name } => {
-        //             log_message("Command 'template info' is not implemented yet.", "WARNING");
-        //         }
-        //     }
+        CliCommands::Template { command } =>
+            match command {
+                CliTemplateCommand::List => {
+                    handle_template_list_command();
+                }
+                CliTemplateCommand::Info { name } => {
+                    handle_template_info_command(name);
+                }
+            }
 
         CliCommands::Build { entry, output, watch, compilation_mode, debug, compress } => {
-            handle_build_command(entry, output);
+            handle_build_command(config, entry, output, watch);
         }
 
         CliCommands::Check { entry, output, watch, compilation_mode, debug } => {
-            handle_check_command(entry, output);
+            handle_check_command(config, entry, output, watch);
         }
 
         // TODO - Implement the play command

package/rust/utils/config.rs

@@ -0,0 +1,13 @@
+use std::{ fs, path::Path };
+use crate::core::types::config::DevalangConfig;
+
+pub fn load_config(path: Option<&Path>) -> Option<DevalangConfig> {
+    let config_path = path.unwrap_or_else(|| Path::new(".devalang"));
+
+    if config_path.exists() {
+        let content = fs::read_to_string(config_path).ok()?;
+        toml::from_str(&content).ok()
+    } else {
+        None
+    }
+}

package/rust/utils/file.rs

@@ -0,0 +1,35 @@
+use std::{ fs::{ self }, path::Path };
+use include_dir::{ Dir, DirEntry };
+
+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) => {
+                let rel_path = file.path().strip_prefix(base_path).unwrap();
+                let dest_path = target_root.join(rel_path);
+
+                if let Some(parent) = dest_path.parent() {
+                    fs::create_dir_all(parent).unwrap();
+                }
+
+                fs::write(&dest_path, file.contents()).expect("Error writing file");
+            }
+        }
+    }
+}
+
+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)
+    }
+}

package/rust/utils/mod.rs

@@ -2,4 +2,7 @@ pub mod version;
 pub mod signature;
 pub mod path;
 pub mod loader;
-pub mod logger;
+pub mod logger;
+pub mod file;
+pub mod watcher;
+pub mod config;

package/rust/utils/watcher.rs

@@ -0,0 +1,25 @@
+use notify::{ Watcher, RecursiveMode, Config, RecommendedWatcher };
+use std::sync::mpsc::channel;
+
+pub fn watch_directory<F>(entry: String, callback: F) -> notify::Result<()>
+    where F: Fn() + Send + 'static
+{
+    let (tx, rx) = channel();
+
+    let mut watcher: RecommendedWatcher = Watcher::new(tx, Config::default())?;
+    watcher.watch(&entry.as_ref(), RecursiveMode::Recursive)?;
+
+    loop {
+        match rx.recv() {
+            Ok(_) => {
+                callback();
+            }
+            Err(e) => {
+                eprintln!("Channel error : {:?}", e);
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}

package/templates/minimal/.devalang

@@ -0,0 +1,4 @@
+[defaults]
+entry = "./src"
+output = "./output"
+watch = true

package/templates/minimal/src/index.deva

@@ -0,0 +1,2 @@
+# Write your Devalang code here
+# ...

package/templates/welcome/.devalang

@@ -0,0 +1,4 @@
+[defaults]
+entry = "./src"
+output = "./output"
+watch = true

package/templates/welcome/README.md

@@ -0,0 +1,185 @@
+<div align="center">
+    <img src="https://firebasestorage.googleapis.com/v0/b/devaloop-labs.firebasestorage.app/o/devalang-teal-logo.svg?alt=media&token=d2a5705a-1eba-4b49-88e6-895a761fb7f7" alt="Devalang Logo">
+</div>
+
+![Rust](https://img.shields.io/badge/Made%20with-Rust-orange?logo=rust)
+![TypeScript](https://img.shields.io/badge/Built%20with-TypeScript-blue?logo=typescript)
+![Node.js](https://img.shields.io/badge/Node.js-18%2B-brightgreen?logo=node.js)
+
+![Project Status](https://img.shields.io/badge/status-alpha-red)
+![Version](https://img.shields.io/badge/version-0.0.1-blue)
+![License: MIT](https://img.shields.io/badge/license-MIT-green)
+![Platform](https://img.shields.io/badge/platform-Windows-blue)
+
+![npm](https://img.shields.io/npm/dm/@devaloop/devalang)
+
+## 🎼 Devalang, by **Devaloop Labs**
+
+🎶 Compose music with code — simple, structured, sonic.
+
+Devalang is a tiny domain-specific language (DSL) for music makers, sound designers, and audio hackers.
+Compose loops, control samples, and automate parameters — all in clean, readable text.
+
+🦊 Whether you're building a track, shaping textures, or performing live, Devalang helps you think in rhythms. It’s designed to be simple, expressive, and fast — because your ideas shouldn’t wait.
+
+From studio sketches to live sets, Devalang gives you rhythmic control — with the elegance of code.
+
+> 🚧 **v0.0.1-alpha.1 Notice** 🚧
+>
+> Devalang is still in early development. This version does not yet include **sound rendering**.
+>
+> You can parse code, generate the AST, and validate syntax — all essential building blocks for the upcoming audio engine.
+>
+> Currently, only `.kick` is included as a built-in trigger.
+> Custom instruments can be defined with `@load`, allowing any sound sample to be triggered with the same syntax.
+>
+> Currently, Devalang CLI is only available for **Windows**.  
+> Linux and macOS binaries will be added in future releases via cross-platform builds.
+
+## 🚀 Features
+
+- 🧩 Module system for importing and exporting variables between files (`@import`, `@export`)
+- 📜 Structured AST generation for debugging and future compilation
+- 🔢 Basic data types: strings, numbers, booleans, maps, arrays
+- 👁️ Watch mode for `build` and `check` commands
+- ⏱️ `bpm` assignment for setting tempo
+- 🧱 `bank` declaration to define the instrument set
+- 🔁 Looping system with fixed repetitions (`loop 4:`)
+- 🧪 Instruction calls with parameters (e.g. `.kick auto {reverb:10, decay:20}`) for testing pattern syntax
+- 📄 `let` assignments for storing reusable values
+- 🔄 `@load` assignment to load a sample (.mp3, .wav) to use it as a value
+- 🛠️ CLI tools for syntax checking (`check`), AST output (`build`)
+
+## 📆 Installation
+
+### For users
+
+> - ⚠️ Requires [Node.js 18+](https://nodejs.org/en/download)
+
+Install the package globally (NPM)
+
+```bash
+npm install -g @devaloop/devalang
+```
+
+Usage without install (NPX)
+
+```bash
+npx @devaloop/devalang <command>
+```
+
+### For contributors
+
+> - ⚠️ Requires [Node.js 18+](https://nodejs.org/en/download)
+> - ⚠️ Requires [Rust 1.70+](https://www.rust-lang.org/learn/get-started#installing-rust)
+
+```bash
+> git clone https://github.com/devaloop-labs/devalang.git
+> cd devalang
+> npm install
+> cargo install --path .
+```
+
+Usage for development (feel free to change arguments in package.json)
+
+```bash
+# For syntax checking test
+npm run rust:dev <command>
+```
+
+## ❔ Usage
+
+For more examples, see [docs/COMMANDS.md](./docs/COMMANDS.md)
+
+### Initialize a new project
+
+In the current directory
+
+```bash
+devalang init
+```
+
+Or use optional arguments to specify a directory name and a template
+
+```bash
+devalang init --name <project-name> --template <template-name>
+```
+
+### Checking syntax only and output debug files
+
+```bash
+devalang check --entry <entry-directory> --output <output-directory> --watch
+```
+
+### Building output file(s) (AST generation for the moment)
+
+```bash
+devalang build --entry <entry-directory> --output <output-directory> --watch
+```
+
+## ⚙️ Configuration
+
+You can use a configuration file to set default values for various settings, making it easier to manage your Devalang project.
+
+To do this, create a `.devalang` file in the root of your project directory.
+
+See [docs/CONFIG.md](./docs/CONFIG.md) for more information.
+
+## 📄 Syntax example
+
+For more examples, see [docs/SYNTAX.md](./docs/SYNTAX.md)
+
+```deva
+# index.deva
+
+@import { globalBpm, globalBank, kickDuration } from "global.deva"
+
+bpm globalBpm
+# Will declare the tempo at the globalBpm variable beats per minute
+
+bank globalBank
+# Will declare a custom instrument bank using the globalBank variable
+
+loop 5:
+    .kick kickDuration {reverb=50, drive=25}
+    # Will play 5 times a kick for the duration of the kickDuration variable with reverb and drive effects
+```
+
+```deva
+# global.deva
+
+let globalBpm = 120
+let globalBank = 808
+let kickDuration = 500
+
+@export { globalBpm, globalBank, kickDuration }
+```
+
+## 🧯 Known issues
+
+- No support yet for Audio Engine
+- No support yet for `if`, `else`, `else if` statements
+- No support yet for `@group`, `@pattern`, `@function` statements
+- Nested loops and conditions may not be fully tested
+
+## 🧪 Roadmap Highlights
+
+For more info, see [docs/ROADMAP.md](./docs/ROADMAP.md)
+
+- ⏳ Audio engine integration
+- ⏳ Other statements (e.g `if`, `@group`, ...)
+- ⏳ Cross-platform support (Linux, macOS)
+- ⏳ More built-in instruments (e.g. snare, hi-hat, etc.)
+
+## 🛡️ License
+
+MIT — see [LICENSE](./LICENSE)
+
+## 🤝 Contributing
+
+Contributions, bug reports and suggestions are welcome !  
+Feel free to open an issue or submit a pull request.
+
+## 📢 Contact
+
+📧 [contact@devaloop.com](mailto:contact@devaloop.com)

package/templates/welcome/src/index.deva

@@ -0,0 +1,13 @@
+# 🦊 Welcome to Devalang !
+# This is your first Devalang program ?
+# Let's start with a simple example that plays a sample in a loop.
+
+@import { bpmVar, bankVar, loopVar } from './variables.deva'
+@load "../samples/kick-808.wav" as sample
+
+bpm bpmVar
+
+bank bankVar
+
+loop loopVar:
+    .sample auto

package/templates/welcome/src/variables.deva

@@ -0,0 +1,5 @@
+let bpmVar = 120
+let bankVar = 808
+let loopVar = 10
+
+@export { bpmVar, bankVar, loopVar }

package/rust/cli/new.rs

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