@devaloop/devalang 0.0.1-alpha.1

package/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "devalang"
+version = "0.0.1-alpha.1"
+authors = ["Devaloop <contact@devaloop.com>"]
+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."
+license = "MIT"
+repository = "https://github.com/devaloop-labs/devalang"
+keywords = ["music", "dsl", "audio", "cli"]
+categories = ["command-line-utilities", "audio", "development-tools"]
+readme = "README.md"
+homepage = "https://devaloop.com"
+documentation = "https://docs.rs/devalang"
+edition = "2024"
+
+[[bin]]
+name = "devalang"
+path = "rust/main.rs"
+
+[lib]
+path = "rust/lib.rs"
+crate-type = ["cdylib"]
+
+[profile.release]
+opt-level = "s"
+
+[features]
+default = ["cli"]
+cli = ["crossterm"]
+
+[dependencies]
+clap = { version = "4.5", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+rodio = "0.17"
+hound = "3.4.0"
+toml = "0.8"
+notify = "6.1"
+fs_extra = "1.3"
+include_dir = "0.7"
+wasm-bindgen = "0.2"
+serde-wasm-bindgen = "0.4"
+nom_locate = "4.0.0"
+chrono = "0.4"
+crossterm =  { version = "0.27", optional = true }
+indicatif = "0.17"

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Devaloop Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell    
+copies of the Software, and to permit persons to whom the Software is        
+furnished to do so, subject to the following conditions:                     
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.                              
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR   
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,     
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,161 @@
+<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
+- ⏱️ `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)
+
+Checking syntax only and output debug files
+
+```bash
+devalang check --entry <entry-directory> --output <output-directory>
+```
+
+Building output file(s) (AST generation for the moment)
+
+```bash
+devalang build --entry <entry-directory> --output <output-directory>
+```
+
+## 📄 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`, ...)
+- ⏳ Watch mode for automatic rebuilds
+
+## 🛡️ 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/docs/COMMANDS.md

@@ -0,0 +1,31 @@
+<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>
+
+# Devalang Commands Guide
+
+## Checking
+
+Checking syntax of .deva file(s)
+
+```bash
+devalang check --entry ./examples --output ./output
+```
+
+Available arguments :
+
+- `entry`: The input folder (default to `./src`)
+- `output`: The output folder (default to `./output`)
+
+## Building
+
+Building AST of .deva file(s)
+
+```bash
+devalang build --entry ./examples --output ./output
+```
+
+Available arguments :
+
+- `entry`: The input folder (default to `./src`)
+- `output`: The output folder (default to `./output`)

package/docs/ROADMAP.md

@@ -0,0 +1,27 @@
+<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>
+
+# Roadmap
+
+Devalang is a work in progress. Here’s what we’re planning next:
+
+- ✅ **Basic syntax**: Implement the core syntax for Devalang, including data types and basic statements.
+- ✅ **Module system**: Add support for importing and exporting variables between files using `@import` and `@export`.
+- ✅ **AST generation**: Implement the Abstract Syntax Tree (AST) generation for debugging and future compilation.
+- ✅ **Basic data types**: Support strings, numbers, booleans, maps, and arrays.
+- ✅ **BPM assignment**: Implement `bpm` assignment to set the tempo.
+- ✅ **Bank declaration**: Add `bank` declaration to define the instrument set.
+- ✅ **Looping system**: Implement a looping system with fixed repetitions using `loop 4:`.
+- ✅ **Instruction calls**: Add support for instruction calls with parameters (e.g. `.kick auto {reverb:10, decay:20}`).
+- ✅ **Let assignments**: Implement `let` assignments for storing reusable values.
+- ✅ **Sample loading**: Add `@load` assignment to load samples (.mp3, .wav) for use as values.
+
+- ⏳ **VSCode extension**: Create a VSCode extension for syntax highlighting and code completion.
+- ⏳ **WASM support**: Compile Devalang to WebAssembly for use in web applications.
+- ⏳ **Other statements**: Implement `if`, `else`, and other control structures.
+- ⏳ **Pattern and group statements**: Add support for `@pattern` and `@group` to organize code.
+- ⏳ **Watch mode**: Add a watch mode to automatically rebuild on file changes.
+- ⏳ **Functions**: Add support for defining and calling functions.
+- ⏳ **Audio engine**: Integrate the audio engine for sound playback.
+- ⏳ **Testing**: Expand test coverage for all features.

package/docs/SYNTAX.md

@@ -0,0 +1,148 @@
+<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>
+
+# Devalang Syntax Guide
+
+Devalang supports a simple and intuitive syntax for composing music and sound design. Below is a guide to the basic syntax elements, types, and usage examples.
+
+The engine is designed to be easy to read and write, allowing you to focus on your music rather than the code.
+
+The engine uses indentation to define blocks, similar to Python. Each block must be indented consistently.
+
+➡️ For full examples, check the `examples/` folder of the repository.
+
+## Types
+
+<details>
+<summary>Show available types</summary>
+
+### String
+
+Strings are defined using double quotes.
+
+```deva
+let string = "myValue"
+```
+
+### Number
+
+Numbers can be integers or floating-point values. They do not require quotes.
+
+```deva
+let number = 99
+```
+
+### Boolean
+
+Booleans can be either `true` or `false` without quotes.
+
+```deva
+let boolean = false
+```
+
+### Map
+
+Maps are key-value pairs defined using curly braces. Keys are strings, and values can be of any type (string, number, boolean, map, or array).
+
+```deva
+let map = {myKey: 99}
+```
+
+### Array
+
+Arrays are ordered lists of values defined using square brackets. Values can be of any type (string, number, boolean, map, or array).
+
+```deva
+let array = [3, 4]
+```
+
+</details>
+
+## Syntax usage
+
+### Beats Per Minute
+
+BPM is used to set the global tempo of the music.
+
+```deva
+bpm 125
+```
+
+### Sound Bank
+
+Bank is used to select a sound bank for the audio engine.
+
+```deva
+bank 808
+```
+
+### Importing / Exporting Modules
+
+Modules can be imported and exported to share variables between different files.
+
+Exporting variables from a module :
+
+```deva
+# exported.deva
+
+let exportedIterator = 10
+let exportedParams = {drive: 50, decay: 30}
+
+@export { exportedIterator, exportedParams }
+```
+
+Importing and using the exported variables in another module :
+
+```deva
+# index.deva
+
+@import { exportedIterator, exportedParams } "./exported.deva"
+
+loop exportedIterator:
+    .kick auto exportedParams
+```
+
+### Built-in triggers
+
+Usage : `.<trigger-name> <duration> <effects-map>`
+
+Other triggers will be added in future releases (e.g. `.snare`, `.hihat`, `.tom`, `.clap`, `.crash`, `.ride`, `.synth`, `.bass`, `.pad`).
+You can also create custom triggers using the `@load` directive.
+
+```deva
+.kick
+.kick 1/4
+.kick auto {reverb: 50, decay: 30}
+```
+
+### Custom triggers
+
+Same usage as built-in triggers, but with custom audio files or effects.
+
+```deva
+@load "./path/to/instrument.mp3" as mySample
+
+.mySample auto {reverb: 50, drive: 25}
+```
+
+### Let variables
+
+Variables are defined using the `let` keyword, followed by the variable name and its value. The value can be of any type (string, number, boolean, map, or array).
+
+```deva
+let number = 0
+let boolean = true
+let string = "string"
+let map = {myKey: 200}
+let array = [0, 1, 2]
+```
+
+### Basic loops
+
+Loops are defined using the `loop` keyword, followed by the number of iterations. The body of the loop is indented.
+
+```deva
+loop 10:
+    # ...
+```

package/docs/TODO.md

@@ -0,0 +1,66 @@
+<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>
+
+# TODOs list
+
+This is a list of tasks and features to be implemented in Devalang. Note that this is not an exhaustive list, and some items may be added or removed over time.
+
+## Commands
+
+- [ ] New project
+- [ ] Template
+  - [ ] Implement template list
+  - [ ] Implement template info
+- [x] Checking
+  - [ ] Implement watch mode
+  - [ ] Implement debug mode
+  - [ ] Implement compilation mode
+- [x] Building
+  - [ ] Implement watch mode
+  - [ ] Implement debug mode
+  - [ ] Implement compilation mode
+  - [ ] Implement compression mode
+- [ ] Play
+  - [ ] Implement Audio Engine
+  - [ ] Implement loop mode
+
+## Core components
+
+- [ ] Audio Engine
+- [x] Lexer
+- [x] Parser
+- [x] Preprocessor
+- [x] Debugger
+- [x] Builder
+
+## Syntax elements
+
+- [ ] #
+- [x] @import
+- [x] @export
+- [ ] @group
+- [ ] @pattern
+- [ ] @function
+- [x] @load
+- [ ] @include
+- [x] bpm
+- [x] bank
+- [x] loop
+- [x] let
+- [ ] if
+- [ ] else
+- [ ] else if
+
+## Built-in triggers
+
+- [x] .kick
+- [ ] .snare
+- [ ] .hihat
+- [ ] .tom
+- [ ] .clap
+- [ ] .crash
+- [ ] .ride
+- [ ] .synth
+- [ ] .bass
+- [ ] .pad

package/examples/exported.deva

@@ -0,0 +1,7 @@
+let duration = auto
+let default_bank = 808
+let params = {decay:10, delay:30}
+let loopCount = 15
+let tempo = 155
+
+@export { duration, default_bank, params, loopCount, tempo }

package/examples/index.deva

@@ -0,0 +1,9 @@
+@import { duration, default_bank, params, loopCount, tempo } from "./examples/exported.deva"
+@load "./examples/samples/kick-808.wav" as sample
+
+bpm tempo
+
+bank default_bank
+
+loop loopCount:
+    .sample duration params

package/out-tsc/bin/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const binaryPath = path_1.default.join(__dirname, "devalang.exe");
+const subCommand = process.argv[2] || "help";
+const args = process.argv.slice(2);
+const child = (0, child_process_1.spawn)(binaryPath, args, { stdio: "inherit" });
+child.on("exit", (code) => process.exit(code));

package/out-tsc/index.js

@@ -0,0 +1,2 @@
+"use strict";
+// This file is part of the Devalang project

package/out-tsc/scripts/postbuild.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const source = path_1.default.join(__dirname, "..", "..", "target", "release", "devalang.exe");
+const destination = path_1.default.join(__dirname, "..", "bin", "devalang.exe");
+fs_1.default.copyFileSync(source, destination);
+fs_1.default.chmodSync(destination, 0o755);

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

@@ -0,0 +1,52 @@
+"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.bumpVersion = void 0;
+const fs_1 = __importDefault(require("fs"));
+const bumpVersion = (bumpType, projectVersionPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const versionData = JSON.parse(fs_1.default.readFileSync(projectVersionPath, "utf-8"));
+    const versionRegex = /^(\d+)\.(\d+)\.(\d+)(?:-([\w.]+))?$/;
+    const match = versionData.version.match(versionRegex);
+    if (!match) {
+        throw new Error("Invalid version format in project-version.json");
+    }
+    if (!bumpType) {
+        console.error("❌ Please specify a version type (major, minor, patch, pre)");
+        process.exit(1);
+    }
+    let [_, major, minor, patch, pre] = match;
+    let nextVersion = "";
+    switch (bumpType) {
+        case "major":
+            nextVersion = `${+major + 1}.0.0`;
+            break;
+        case "minor":
+            nextVersion = `${major}.${+minor + 1}.0`;
+            break;
+        case "patch":
+            nextVersion = `${major}.${minor}.${+patch + 1}`;
+            break;
+        case "pre":
+            const [preid, prenumber] = (pre || "alpha.0").split(".");
+            nextVersion = `${major}.${minor}.${patch}-${preid}.${+prenumber + 1}`;
+            break;
+        default:
+            console.error("❌ Version type non-recognized (major, minor, patch, pre)");
+            process.exit(1);
+    }
+    versionData.version = nextVersion;
+    fs_1.default.writeFileSync(projectVersionPath, JSON.stringify(versionData, null, 2));
+    return nextVersion;
+});
+exports.bumpVersion = bumpVersion;

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

@@ -0,0 +1,34 @@
+"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.fetchVersion = void 0;
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const fetchVersion = (projectVersionPath) => __awaiter(void 0, void 0, void 0, function* () {
+    // Lire le fichier
+    const data = JSON.parse(fs_1.default.readFileSync(projectVersionPath, "utf-8"));
+    // Incrémenter le numéro de build
+    data.build = (data.build || 0) + 1;
+    // Récupérer le dernier hash git
+    try {
+        const commit = (0, child_process_1.execSync)("git rev-parse HEAD").toString().trim();
+        data.lastCommit = commit;
+    }
+    catch (err) {
+        console.warn("⚠️ Impossible de récupérer le hash git.");
+    }
+    // Écrire la mise à jour
+    fs_1.default.writeFileSync(projectVersionPath, JSON.stringify(data, null, 2));
+});
+exports.fetchVersion = fetchVersion;

package/out-tsc/scripts/version/index.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 });
+const path_1 = __importDefault(require("path"));
+const bump_1 = require("./bump");
+const sync_1 = require("./sync");
+const fetch_1 = require("./fetch");
+const bumpType = process.argv[2] || "patch";
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    const projectVersionPath = path_1.default.join(__dirname, "../../../project-version.json");
+    try {
+        const newVersion = yield (0, bump_1.bumpVersion)(bumpType, projectVersionPath);
+        yield (0, fetch_1.fetchVersion)(projectVersionPath);
+        yield (0, sync_1.syncVersion)(projectVersionPath);
+        console.log(`✅ Project version updated to : ${newVersion}`);
+    }
+    catch (error) {
+        console.error(`❌ Error updating project version: ${error}`);
+        process.exit(1);
+    }
+}))();