@devaloop/devalang 0.0.1-alpha.15 → 0.0.1-alpha.16

package/rust/utils/telemetry.rs

@@ -0,0 +1,292 @@
+use crate::{
+    common::api::get_api_url,
+    config::{driver::ProjectConfig, settings::get_user_config, stats::ProjectStats},
+};
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+#[derive(Serialize, Deserialize, Default, Clone)]
+pub enum TelemetryErrorLevel {
+    #[default]
+    None,
+    Warning,
+    Critical,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone)]
+pub struct TelemetryProjectInfo {
+    config: Option<TelemetryProjectInfoConfig>,
+    stats: Option<TelemetryProjectInfoStats>,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug)]
+pub struct TelemetryProjectInfoStats {
+    counts: TelemetryProjectInfoStatsCounts,
+    features: TelemetryProjectInfoStatsFeatures,
+    audio: TelemetryProjectInfoStatsAudio,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug)]
+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)]
+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)]
+pub struct TelemetryProjectInfoStatsAudio {
+    pub avg_bpm: Option<u32>,
+    pub has_synths: bool,
+    pub has_samples: bool,
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Debug)]
+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)]
+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,
+}
+
+impl TelemetryEvent {
+    pub fn set_timestamp(&mut self, timestamp: String) {
+        self.timestamp = timestamp;
+    }
+
+    pub fn set_duration(&mut self, duration: u64) {
+        self.duration = duration;
+    }
+
+    pub fn set_success(&mut self, success: bool) {
+        self.success = success;
+    }
+
+    pub fn set_error(
+        &mut self,
+        level: TelemetryErrorLevel,
+        message: Option<String>,
+        exit_code: Option<i32>,
+    ) {
+        self.error_level = level;
+        self.error_message = message;
+        self.exit_code = exit_code;
+    }
+}
+
+pub struct TelemetryEventCreator {
+    pub events: Vec<TelemetryEvent>,
+}
+
+impl TelemetryEventCreator {
+    pub fn new() -> Self {
+        TelemetryEventCreator { events: Vec::new() }
+    }
+
+    pub fn create_event(&mut self, event: TelemetryEvent) {
+        self.events.push(event.clone());
+    }
+
+    pub fn get_base_event(&self) -> TelemetryEvent {
+        let mut stats_enabled = false;
+
+        let user_config = get_user_config().unwrap_or_default();
+
+        if user_config.telemetry.stats == true {
+            stats_enabled = true;
+        }
+
+        let mut event: TelemetryEvent = TelemetryEvent {
+            uuid: user_config.telemetry.uuid.clone(),
+            cli_version: env!("CARGO_PKG_VERSION").to_string(),
+            os: std::env::consts::OS.to_string(),
+            command: std::env::args().collect::<Vec<_>>(),
+            project_info: None,
+            error_level: TelemetryErrorLevel::None,
+            error_message: None,
+            exit_code: None,
+            timestamp: chrono::Utc::now().to_string(),
+            duration: 0,
+            success: true,
+        };
+
+        let project_settings = ProjectConfig::get();
+        let project_stats = ProjectStats::get();
+
+        if project_settings.is_ok() && project_stats.is_ok() {
+            let project_settings = project_settings.unwrap();
+            let project_stats = project_stats.unwrap();
+
+            let mut stats = None;
+
+            if stats_enabled {
+                stats = Some(TelemetryProjectInfoStats {
+                    counts: TelemetryProjectInfoStatsCounts {
+                        nb_files: project_stats.counts.nb_files,
+                        nb_modules: project_stats.counts.nb_modules,
+                        nb_lines: project_stats.counts.nb_lines,
+                        nb_banks: project_stats.counts.nb_banks,
+                        nb_plugins: project_stats.counts.nb_plugins,
+                    },
+                    features: TelemetryProjectInfoStatsFeatures {
+                        uses_imports: project_stats.features.uses_imports,
+                        uses_functions: project_stats.features.uses_functions,
+                        uses_groups: project_stats.features.uses_groups,
+                        uses_automations: project_stats.features.uses_automations,
+                        uses_loops: project_stats.features.uses_loops,
+                    },
+                    audio: TelemetryProjectInfoStatsAudio {
+                        avg_bpm: project_stats.audio.avg_bpm,
+                        has_synths: project_stats.audio.has_synths,
+                        has_samples: project_stats.audio.has_samples,
+                    },
+                });
+            }
+
+            event.project_info = Some(TelemetryProjectInfo {
+                config: Some(TelemetryProjectInfoConfig {
+                    entry_defined: project_settings.defaults.entry.is_some(),
+                    output_defined: project_settings.defaults.output.is_some(),
+                    watch_defined: project_settings.defaults.watch.is_some(),
+                    repeat_defined: project_settings.defaults.repeat.is_some(),
+                    debug_defined: project_settings.defaults.debug.is_some(),
+                    compress_defined: project_settings.defaults.compress.is_some(),
+                }),
+                stats: stats,
+            });
+        } else {
+            event.project_info = None;
+        }
+
+        event
+    }
+}
+
+pub fn refresh_event_project_info(event: &mut TelemetryEvent) {
+    let user_config = get_user_config().unwrap_or_default();
+    let stats_enabled = user_config.telemetry.stats;
+
+    let project_settings = ProjectConfig::get();
+    let project_stats = ProjectStats::get();
+
+    if project_settings.is_ok() && project_stats.is_ok() {
+        let project_settings = project_settings.unwrap();
+        let project_stats = project_stats.unwrap();
+
+        let mut stats = None;
+        if stats_enabled {
+            stats = Some(TelemetryProjectInfoStats {
+                counts: TelemetryProjectInfoStatsCounts {
+                    nb_files: project_stats.counts.nb_files,
+                    nb_modules: project_stats.counts.nb_modules,
+                    nb_lines: project_stats.counts.nb_lines,
+                    nb_banks: project_stats.counts.nb_banks,
+                    nb_plugins: project_stats.counts.nb_plugins,
+                },
+                features: TelemetryProjectInfoStatsFeatures {
+                    uses_imports: project_stats.features.uses_imports,
+                    uses_functions: project_stats.features.uses_functions,
+                    uses_groups: project_stats.features.uses_groups,
+                    uses_automations: project_stats.features.uses_automations,
+                    uses_loops: project_stats.features.uses_loops,
+                },
+                audio: TelemetryProjectInfoStatsAudio {
+                    avg_bpm: project_stats.audio.avg_bpm,
+                    has_synths: project_stats.audio.has_synths,
+                    has_samples: project_stats.audio.has_samples,
+                },
+            });
+        }
+
+        event.project_info = Some(TelemetryProjectInfo {
+            config: Some(TelemetryProjectInfoConfig {
+                entry_defined: project_settings.defaults.entry.is_some(),
+                output_defined: project_settings.defaults.output.is_some(),
+                watch_defined: project_settings.defaults.watch.is_some(),
+                repeat_defined: project_settings.defaults.repeat.is_some(),
+                debug_defined: project_settings.defaults.debug.is_some(),
+                compress_defined: project_settings.defaults.compress.is_some(),
+            }),
+            stats,
+        });
+    } else {
+        event.project_info = None;
+    }
+}
+
+#[derive(Debug)]
+pub enum TelemetrySendError {
+    Http(String),
+}
+
+pub async fn send_telemetry_event(event: &TelemetryEvent) -> Result<(), TelemetrySendError> {
+    if let Some(cfg) = get_user_config() {
+        if cfg.telemetry.enabled == false {
+            return Ok(());
+        }
+    }
+
+    let telemetry_url = format!("{}/v1/telemetry/send", get_api_url());
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(5))
+        .build()
+        .map_err(|e| TelemetrySendError::Http(format!("client build error: {}", e)))?;
+
+    let mut last_err: Option<String> = None;
+    for (i, delay_ms) in [0u64, 250, 500, 1000].iter().enumerate() {
+        if *delay_ms > 0 {
+            tokio::time::sleep(Duration::from_millis(*delay_ms)).await;
+        }
+
+        let res = client
+            .post(telemetry_url.clone())
+            .json(event)
+            .send()
+            .await
+            .and_then(|r| r.error_for_status());
+
+        match res {
+            Ok(_) => {
+                return Ok(());
+            }
+            Err(err) => {
+                last_err = Some(err.to_string());
+
+                if i == 3 {
+                    break;
+                }
+            }
+        }
+    }
+
+    Err(TelemetrySendError::Http(
+        last_err.unwrap_or_else(|| "unknown error".to_string()),
+    ))
+}

package/rust/utils/watcher.rs

@@ -1,33 +1,34 @@
-use notify::{ Watcher, RecursiveMode, Config, RecommendedWatcher };
-use std::sync::mpsc::channel;
-
-use std::time::{ Duration, Instant };
-
-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)?;
-
-    let mut last_trigger = Instant::now();
-
-    loop {
-        match rx.recv() {
-            Ok(_) => {
-                let now = Instant::now();
-                if now.duration_since(last_trigger) > Duration::from_millis(200) {
-                    callback();
-                    last_trigger = now;
-                }
-            }
-            Err(e) => {
-                eprintln!("Channel error: {:?}", e);
-                break;
-            }
-        }
-    }
-
-    Ok(())
-}
+use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
+use std::sync::mpsc::channel;
+
+use std::time::{Duration, Instant};
+
+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)?;
+
+    let mut last_trigger = Instant::now();
+
+    loop {
+        match rx.recv() {
+            Ok(_) => {
+                let now = Instant::now();
+                if now.duration_since(last_trigger) > Duration::from_millis(200) {
+                    callback();
+                    last_trigger = now;
+                }
+            }
+            Err(e) => {
+                eprintln!("Channel error: {:?}", e);
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}

package/templates/minimal/README.md

@@ -1,5 +1,5 @@
 <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">
+    <img src="https://devalang.com/images/devalang-logo-min.png" alt="Devalang Logo" width="100" />
 </div>
 
 ![Rust](https://img.shields.io/badge/Made%20with-Rust-orange?logo=rust)
@@ -7,184 +7,156 @@
 ![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)
+![Version](https://img.shields.io/npm/v/@devaloop/devalang)
 ![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/dt/@devaloop/devalang)
 ![crates](https://img.shields.io/crates/d/devalang)
 
-## 🎼 Devalang, by **Devaloop Labs**
+[![VSCode Extension](https://img.shields.io/visual-studio-marketplace/v/devaloop.devalang-vscode?label=VSCode%20Extension)](https://marketplace.visualstudio.com/items?itemName=devaloop.devalang-vscode)
 
-🎶 Compose music with code — simple, structured, sonic.
+# 🦊 Devalang (CORE) — Compose music with code
 
 Devalang is a tiny domain-specific language (DSL) for music makers, sound designers, and audio hackers.
 Compose loops, control samples, render and play audio — 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.
+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.5 Notice** 🚧
+> 🚧 Alpha Notice 🚧
 >
-> Currently, Devalang CLI is only available for **Windows**.  
+> Includes synthesis, playback, and rendering features, but is still in early development.
+>
+> Currently, Devalang CLI is only available for **Windows**.
 > Linux and macOS binaries will be added in future releases via cross-platform builds.
 
----
-
 ## 📚 Quick Access
 
-- [📖 Documentation](./docs/)
+- [▶️ Playground](https://playground.devalang.com)
+- [📖 Documentation](https://docs.devalang.com)
+- [🧩 VSCode Extension](https://marketplace.visualstudio.com/items?itemName=devaloop.devalang-vscode)
+- [🎨 Prettier Plugin](https://www.npmjs.com/package/@devaloop/prettier-plugin-devalang)
+- [📜 Changelog](./docs/CHANGELOG.md)
 - [💡 Examples](./examples/)
 - [🌐 Project Website](https://devalang.com)
+- [📦 Devalang CLI on npm](https://www.npmjs.com/package/@devaloop/devalang)
 
-## 🚀 Features
+## ⏱️ Try it now !
 
-- 🎵 **Audio Engine**: Integrated audio playback and rendering
-- 🧩 **Module system** for importing and exporting variables between files
-- 📜 **Structured AST** generation for debugging and future compilation
-- 🔢 **Basic data types**: strings, numbers, booleans, maps, arrays
-- 👁️ **Watch mode** for `build`, `check` and `play` commands
-- 📂 **Project templates** for quick setup
+### Try Devalang in your browser
 
-## 📆 Installation
+> Have a look at the [Playground](https://playground.devalang.com) to try Devalang directly in your browser
 
-### For users
-
-> - ⚠️ Requires [Node.js 18+](https://nodejs.org/en/download)
-
-Install the package globally (NPM)
+### Try Devalang CLI
 
 ```bash
+# Install Devalang CLI globally
 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 .
-```
-
-Development usage (you can customize arguments in package.json)
-
-```bash
-# For syntax checking test
-npm run rust:dev:check
-# For building test
-npm run rust:dev:build
-```
-
-## ❔ Usage
-
-NOTE: Commands are available via `devalang` or `npx @devaloop/devalang`.
-
-NOTE: Arguments can be passed to commands using `--<argument>` syntax. You can also use a configuration file to set default values for various settings, making it easier to manage your Devalang project.
-
-NOTE: Some commands require a mandatory `--entry` argument to specify the input folder, and a `--output` argument to specify the output folder. If not specified, they default to `./src` and `./output` respectively.
-
-For more examples, see [docs/COMMANDS.md](./docs/COMMANDS.md)
-
-### Initialize a new project
-
-In the current directory
-
-```bash
-devalang init
+# Create a new Devalang project
+devalang init --name my-project --template minimal
+cd my-project
 ```
 
-Or use optional arguments to specify a directory name and a template
+Create a new Devalang file `src/index.deva` in the project directory:
 
-```bash
-devalang init --name <project-name> --template <template-name>
-```
-
-### Checking syntax only
-
-```bash
-devalang check --watch
+```deva
+# src/index.deva
+
+group main:
+    let lead = synth sine {
+        attack: 0,
+        decay: 100,
+        sustain: 100,
+        release: 100
+    }
+
+    # Global automation for this synth (applies to subsequent notes)
+    automate lead:
+        param volume {
+            0% = 0.0
+            100% = 1.0
+        }
+        param pan {
+            0% = -1.0
+            100% = 1.0
+        }
+        param pitch {
+            0% = -12.0
+            100% = 12.0
+        }
+
+    lead -> note(C4, {
+        duration: 400,
+        velocity: 0.8,
+        automate: { pan: { 0%: -1.0, 100%: 0.0 } }
+    })
+
+    lead -> note(E4, { duration: 400 })
+    lead -> note(G4, { duration: 600, glide: true, target_freq: 659.25 })
+    lead -> note(B3, { duration: 400, slide: true, target_amp: 0.3 })
+
+    for i in [1, 2, 3]:
+        lead -> note(C5, { duration: 200 })
+
+# Play the lead
+
+call main
 ```
 
-### Building output files
+### And the best part ? You can play it directly from the command line:
 
 ```bash
-devalang build --watch
-```
-
-### Playing audio files (once by file change)
+# Play the Devalang file
+devalang play
 
-```bash
+# Play the Devalang file with watch mode
 devalang play --watch
-```
 
-### Playing audio files (continuous playback, even without file changes)
-
-```bash
+# LIVE mode (repeat the playback + watch mode)
 devalang play --repeat
 ```
 
-## ⚙️ 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
+### 🎉 You can now hear your Devalang code in action
 
-For more examples, see [docs/SYNTAX.md](./docs/SYNTAX.md)
+> For more examples, check out the [examples directory](./examples/)
 
-```deva
-# index.deva
-
-@import { globalBpm, globalBank, kickDuration } from "global.deva"
-
-@load "./examples/samples/kick-808.wav" as customKick
-
-bpm globalBpm
-# Will declare the tempo at the globalBpm variable beats per minute
+## ❓ Why Devalang ?
 
-bank globalBank
-# Will declare a custom instrument bank using the globalBank variable
+- 🎹 Prototype audio ideas without opening a DAW, even VSCode
+- 💻 Integrate sound into code-based workflows
+- 🎛️ Control audio parameters through readable syntax
+- 🧪 Build musical logic with variables and conditions
+- 🔄 Create complex patterns with ease
 
-loop 5:
-    .customKick kickDuration {reverb=50, drive=25}
-    # Will play 5 times a kick for the duration of the kickDuration variable with reverb and drive effects
-```
+## 🚀 Features
 
-```deva
-# global.deva
+- 🎵 **Audio Engine**: Integrated audio playback and rendering
+- 🧩 **Module system** for importing and exporting variables between files
+- 📦 **Addon manager** for managing external banks, plugins and more
+- 📜 **Structured AST** generation for debugging and future compilation
+- 🔢 **Basic data types**: strings, numbers, booleans, maps, arrays
+- 👁️ **Watch mode** for `build`, `check` and `play` commands
+- 📂 **Project templates** for quick setup
+- 🎛️ **Custom samples**: easily load and trigger your own audio files
+- 🔄 **Looping and grouping**: create complex patterns with ease
 
-let globalBpm = 120
-let globalBank = 808
-let kickDuration = 500
+## 📄 Documentation
 
-@export { globalBpm, globalBank, kickDuration }
-```
+### Please refer to the [online documentation](https://docs.devalang.com) for detailed information on syntax, features, and usage examples
 
 ## 🧯 Known issues
 
-- No support yet for `if`, `else`, `else if` statements
-- No support yet for `@group`, `@pattern`, `@function` statements
+- No smart modules yet, all groups, variables, and samples must be explicitly imported where used
 - No support yet for cross-platform builds (Linux, macOS)
 
 ## 🧪 Roadmap Highlights
 
 For more info, see [docs/ROADMAP.md](./docs/ROADMAP.md)
 
-- ⏳ Other statements (e.g `if`, `@group`, ...)
+- ⏳ Other statements (e.g `function`, `pattern`, ...)
 - ⏳ Cross-platform support (Linux, macOS)
 - ⏳ More built-in instruments (e.g. snare, hi-hat, etc.)
 
@@ -197,6 +169,10 @@ MIT — see [LICENSE](./LICENSE)
 Contributions, bug reports and suggestions are welcome !  
 Feel free to open an issue or submit a pull request.
 
+For more info, see [docs/CONTRIBUTING.md](./docs/CONTRIBUTING.md).
+
 ## 📢 Contact
 
+Feel free to reach out for any inquiries or feedback.
+
 📧 [contact@devaloop.com](mailto:contact@devaloop.com)