@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.17

package/typescript/core/types/index.ts

@@ -0,0 +1,4 @@
+export * from "./result";
+export * from "./statement";
+export * from "./value";
+export * from "./plugin";

package/typescript/core/types/plugin.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a plugin export.
+ */
+export interface PluginExport {
+  name: string;
+  kind: string;
+  default?: any;
+}
+
+/**
+ * Represents a plugin.
+ */
+export interface PluginInfo {
+  author: string;
+  name: string;
+  version?: string;
+  description?: string;
+  exports: PluginExport[];
+}

package/typescript/core/types/result.ts

@@ -0,0 +1,29 @@
+/**
+ * Represents an error that occurred during parsing.
+ */
+export interface ErrorResult {
+  message: string;
+  line: number;
+  column: number;
+}
+
+/**
+ * Represents the result of parsing user code.
+ */
+export interface ParseResult {
+  ok: boolean;
+  ast: string;
+  errors: ErrorResult[];
+}
+
+/**
+ * Represents the result of debugging user code.
+ */
+export interface DebugResult {
+  samples_len: number;
+  any_nonzero: boolean;
+  ast: string;
+  note_count: number;
+  global_vars: string[];
+  statements_count: number;
+}

package/typescript/core/types/statement.ts

@@ -0,0 +1,47 @@
+import { Value, Duration } from "./value";
+
+/**
+ * Represents a statement kind in the code.
+ */
+ export type StatementKind =
+   | { kind: "Tempo" }
+   | { kind: "Bank"; alias?: string }
+   | { kind: "Print" }
+   | { kind: "Load"; source: string; alias: string }
+   | { kind: "Use"; name: string; alias?: string }
+   | { kind: "Let"; name: string }
+   | { kind: "Automate"; target: string }
+   | { kind: "ArrowCall"; target: string; method: string; args: Value[] }
+   | { kind: "Function"; name: string; parameters: string[]; body: Statement[] }
+   | { kind: "Synth" }
+   | { kind: "Trigger"; entity: string; duration: Duration; effects?: Value }
+   | { kind: "Sleep" }
+   | { kind: "Call"; name: string; args: Value[] }
+   | { kind: "Spawn"; name: string; args: Value[] }
+   | { kind: "Loop" }
+   | { kind: "Group" }
+   | { kind: "Include"; path: string }
+   | { kind: "Export"; names: string[]; source: string }
+   | { kind: "Import"; names: string[]; source: string }
+   | { kind: "If" }
+   | { kind: "Else" }
+   | { kind: "ElseIf" }
+   | { kind: "Comment" }
+   | { kind: "Indent" }
+   | { kind: "Dedent" }
+   | { kind: "NewLine" }
+   | { kind: "On"; event: string; args?: Value[]; body: Statement[] }
+   | { kind: "Emit"; event: string; payload?: Value }
+   | { kind: "Unknown" }
+   | { kind: "Error"; message: string };
+
+/**
+ * Represents a statement in the code.
+ */
+ export interface Statement {
+   kind: StatementKind;
+   value: Value;
+   indent: number;
+   line: number;
+   column: number;
+ }

package/typescript/core/types/value.ts

@@ -0,0 +1,29 @@
+import { Statement } from "./statement";
+
+/**
+ * Represents a duration in the code.
+ */
+export type Duration =
+  | { Number: number }
+  | { Identifier: string }
+  | { Beat: string }
+  | { Auto: null };
+
+/**
+ * Represents a value in the code.
+ */
+export type Value =
+  | { Boolean: boolean }
+  | { Number: number }
+  | { Duration: Duration }
+  | { Identifier: string }
+  | { String: string }
+  | { Array: Value[] }
+  | { Map: Record<string, Value> }
+  | { Block: Statement[] }
+  | { Sample: string }
+  | { Beat: string }
+  | { Statement: Statement }
+  | { StatementKind: any }
+  | { Unknown: null }
+  | null;

package/typescript/index.ts

@@ -1,3 +1,8 @@
 /**
- * TypeScript wrapper for Devalang.
- */
+ * Public TypeScript definitions for Devalang.
+ * ————————————————————————————————————————
+ * Used to provide TypeScript types for the Devalang WASM package.
+ */
+
+export * as pkg from "./pkg/devalang_core";
+export * as core from "./core/index";

package/typescript/pkg/devalang_core.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This module exports all the core types and functions used in the WASM package.
+ */
+export * from "../../pkg/devalang_core";

package/typescript/scripts/copy-wasm-dts.ts

@@ -0,0 +1,41 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Copies .d.ts files from pkg/ (wasm-pack output) into out-tsc/pkg/
+const ROOT = path.resolve(__dirname, '..', '..');
+const PKG_DIR = path.join(ROOT, 'pkg');
+const OUT_DIR = path.join(ROOT, 'out-tsc', 'pkg');
+
+function ensureDir(p: string): void {
+  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
+}
+
+function copyDir(src: string, dest: string): void {
+  ensureDir(dest);
+  const items = fs.readdirSync(src, { withFileTypes: true });
+  for (const item of items) {
+    const srcPath = path.join(src, item.name);
+    const destPath = path.join(dest, item.name);
+    if (item.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else if (item.isFile() && item.name.endsWith('.d.ts')) {
+      fs.copyFileSync(srcPath, destPath);
+      console.log('copied', srcPath, '->', destPath);
+    }
+  }
+}
+
+function main(): number {
+  if (!fs.existsSync(PKG_DIR)) {
+    console.error('pkg directory not found at', PKG_DIR);
+    return 1;
+  }
+
+  ensureDir(OUT_DIR);
+  copyDir(PKG_DIR, OUT_DIR);
+  console.log('done');
+  return 0;
+}
+
+const exitCode = main();
+if (exitCode !== 0) process.exit(exitCode);

package/rust/cli/bank.rs

@@ -1,462 +0,0 @@
-use std::fs;
-
-use crate::{
-    common::cdn::get_cdn_url,
-    config::loader::{load_config, remove_bank_from_config, update_bank_version_in_config},
-    core::shared::bank::{BankFile, BankInfo},
-    installer::bank::install_bank,
-};
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize)]
-pub struct BankList {
-    bank: Vec<BankInfo>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BankInfoFetched {
-    pub name: String,
-    pub version: String,
-    pub description: String,
-    pub author: String,
-    pub latest_version: String,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BankVersion {
-    pub version: String,
-}
-
-pub async fn handle_update_bank_command(name: Option<String>) -> Result<(), String> {
-    let deva_dir = std::path::Path::new("./.deva");
-    let bank_dir = deva_dir.join("bank");
-
-    if !bank_dir.exists() {
-        fs::create_dir_all(bank_dir.clone())
-            .map_err(|e| format!("Failed to create bank directory: {}", e))?;
-    }
-
-    if let Some(name) = name {
-        let bank_path = bank_dir.join(&name);
-        if !bank_path.exists() {
-            return Err(format!("Bank '{}' is not installed", name));
-        }
-
-        // Update specific bank
-        let latest_version = match fetch_latest_version(name.clone()).await {
-            Ok(version) => version,
-            Err(err) => {
-                eprintln!("❌ Error fetching latest version for '{}': {}", name, err);
-                return Err(format!("Failed to fetch latest version for '{}'", name));
-            }
-        };
-
-        let local_bank_info_path = bank_path.join("bank.toml");
-        let local_version = match fs::read_to_string(&local_bank_info_path)
-            .ok()
-            .and_then(|content| toml::from_str::<BankFile>(&content).ok())
-            .map(|bf| bf.bank.version)
-        {
-            Some(version) => version,
-            None => {
-                eprintln!(
-                    "⚠️ Unable to read local version for '{}', forcing reinstall...",
-                    name
-                );
-                "".to_string() // Force update
-            }
-        };
-
-        if local_version != latest_version.version {
-            if let Err(e) = update_bank(&name, &latest_version.version).await {
-                eprintln!("❌ Error updating bank '{}': {}", name, e);
-            } else {
-                println!(
-                    "✅ Bank '{}' updated to version '{}'",
-                    name, latest_version.version
-                );
-            }
-        } else {
-            println!(
-                "Bank '{}' is already up-to-date (version {})",
-                name, latest_version.version
-            );
-
-            // Verify if the bank directory exists
-            if !bank_path.exists() {
-                eprintln!(
-                    "❌ Bank directory for '{}' does not exist, reinstalling...",
-                    name
-                );
-                if let Err(e) = install_bank(&name, deva_dir).await {
-                    eprintln!("❌ Error reinstalling bank '{}': {}", name, e);
-                } else {
-                    println!("✅ Bank '{}' reinstalled successfully!", name);
-                }
-            }
-        }
-    } else {
-        // Update all banks
-        let root_dir = deva_dir
-            .parent()
-            .ok_or_else(|| "Failed to determine root directory".to_string())?;
-
-        let config_path = root_dir.join(".devalang");
-        if !config_path.exists() {
-            return Err(format!(
-                "Config file not found at '{}'. Please run 'devalang init' before adding an addon",
-                config_path.display()
-            ));
-        }
-
-        let config = load_config(Some(&config_path))
-            .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-        let config_banks = config.banks.clone();
-
-        // Install or update all banks
-
-        if let Some(banks) = config_banks {
-            for bank in banks {
-                let bank_name = bank
-                    .path
-                    .strip_prefix("devalang://bank/")
-                    .unwrap_or(&bank.path)
-                    .to_string();
-
-                let latest_version = match fetch_latest_version(bank_name.clone()).await {
-                    Ok(version) => version,
-                    Err(err) => {
-                        eprintln!(
-                            "❌ Error fetching latest version for '{}': {}",
-                            bank_name, err
-                        );
-                        continue;
-                    }
-                };
-
-                if let Some(local_bank_version) = bank.version {
-                    if latest_version.version != local_bank_version {
-                        if let Err(e) = update_bank(&bank_name, &latest_version.version).await {
-                            eprintln!("❌ Error updating bank '{}': {}", bank_name, e);
-                        } else {
-                            println!(
-                                "✅ Bank '{}' updated to version '{}'",
-                                bank_name, latest_version.version
-                            );
-                        }
-                    } else {
-                        println!(
-                            "Bank '{}' is already up-to-date (version {})",
-                            bank_name, local_bank_version
-                        );
-
-                        // Verify if the bank directory exists
-                        let bank_path = bank_dir.join(&bank_name);
-
-                        if !bank_path.exists() {
-                            eprintln!(
-                                "❌ Bank directory for '{}' does not exist, reinstalling...",
-                                bank_name
-                            );
-                            if let Err(e) = install_bank(&bank_name, deva_dir).await {
-                                eprintln!("❌ Error reinstalling bank '{}': {}", bank_name, e);
-                            } else {
-                                println!("✅ Bank '{}' reinstalled successfully!", bank_name);
-                            }
-                        }
-                    }
-                } else {
-                    // If the bank version is not specified in the config, install it
-                    if let Err(e) = install_bank(&bank_name, deva_dir).await {
-                        eprintln!("❌ Error installing bank '{}': {}", bank_name, e);
-                    } else {
-                        println!("✅ Bank '{}' installed successfully!", bank_name);
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
-async fn update_bank(bank_name: &str, latest_version: &str) -> Result<(), String> {
-    let deva_dir = std::path::Path::new("./.deva");
-
-    // First, delete the existing bank directory
-    let bank_dir = deva_dir.join("bank").join(bank_name);
-
-    if bank_dir.exists() {
-        std::fs::remove_dir_all(&bank_dir).unwrap_or_else(|_| {
-            eprintln!(
-                "⚠️ Failed to remove old bank directory for '{}', aborting !",
-                bank_name
-            );
-            std::process::exit(1);
-        });
-    }
-
-    // Now, install the new version
-    if let Err(e) = install_bank(bank_name, deva_dir).await {
-        eprintln!("❌ Error installing bank '{}': {}", bank_name, e);
-    } else {
-        println!("✅ Bank '{}' installed successfully!", bank_name);
-    }
-
-    let root_dir = deva_dir
-        .parent()
-        .ok_or_else(|| "Failed to determine root directory".to_string())?;
-
-    let config_path = root_dir.join(".devalang");
-    if !config_path.exists() {
-        return Err(format!(
-            "Config file not found at '{}'. Please run 'devalang init' before adding an addon",
-            config_path.display()
-        ));
-    }
-
-    let mut config = load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    // Update the bank version in the config
-    update_bank_version_in_config(&mut config, bank_name, latest_version);
-
-    Ok(())
-}
-
-pub async fn handle_remove_bank_command(name: String) -> Result<(), String> {
-    let deva_dir = std::path::Path::new("./.deva");
-    let bank_dir = deva_dir.join("bank");
-
-    let bank_path = bank_dir.join(&name);
-
-    if !bank_path.exists() {
-        return Err(format!("Bank '{}' is not installed", name));
-    }
-
-    std::fs::remove_dir_all(&bank_path).map_err(|e| format!("Failed to remove bank: {}", e))?;
-
-    // Remove the bank from the config
-    let root_dir = deva_dir
-        .parent()
-        .ok_or_else(|| "Failed to determine root directory".to_string())?;
-
-    let config_path = root_dir.join(".devalang");
-    if !config_path.exists() {
-        return Err(format!(
-            "Config file not found at '{}'. Please run 'devalang init' before adding an addon",
-            config_path.display()
-        ));
-    }
-
-    let mut config = load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    remove_bank_from_config(&mut config, &name);
-
-    println!("✅ Bank '{}' removed successfully", name);
-
-    Ok(())
-}
-
-pub async fn handle_bank_available_command() -> Result<(), String> {
-    let bank_list = match list_external_banks().await {
-        Ok(list) => list,
-        Err(_err) => {
-            eprintln!("❌ Error fetching bank list");
-            return Err("Failed to fetch bank list".into());
-        }
-    };
-
-    println!("Available banks for current project :");
-    println!(" ");
-
-    for bank in bank_list {
-        println!("📦 {}", bank.name);
-        println!("   - Version: {}", bank.version);
-        println!("   - Description: {}", bank.description);
-        println!("   - Author: {}", bank.author);
-        println!(" ");
-    }
-
-    Ok(())
-}
-
-pub async fn handle_bank_info_command(
-    name: String,
-) -> Result<BankInfo, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/{}/info", cdn_url, name);
-
-    let response = match reqwest::get(&url).await {
-        Ok(resp) => resp,
-        Err(_err) => {
-            return Err("Failed to fetch bank info".into());
-        }
-    };
-
-    if !response.status().is_success() {
-        return Err(format!("Failed to fetch bank info: HTTP {}", response.status()).into());
-    }
-
-    let bytes = match response.bytes().await {
-        Ok(b) => b,
-        Err(_err) => {
-            eprintln!("❌ Error reading response body");
-            return Err("Failed to read response body".into());
-        }
-    };
-
-    let parsed: BankInfo = serde_json::from_slice(&bytes)?;
-
-    println!("📦 Bank Info for '{}':", name);
-    println!("  - Name: {}", parsed.name);
-    println!("  - Version: {}", parsed.version);
-    println!("  - Description: {}", parsed.description);
-    println!("  - Author: {}", parsed.author);
-
-    Ok(parsed)
-}
-
-pub async fn handle_bank_list_command() -> Result<(), String> {
-    let bank_list = match list_installed_banks().await {
-        Ok(list) => list,
-        Err(_err) => {
-            eprintln!("❌ Error fetching bank list");
-            return Err("Failed to fetch bank list".into());
-        }
-    };
-
-    println!("Installed banks for current project :");
-
-    for bank_toml in bank_list {
-        let latest_version = match fetch_latest_version(bank_toml.bank.name.clone()).await {
-            Ok(version) => version,
-            Err(_err) => {
-                eprintln!(
-                    "❌ Error fetching latest version for '{}'",
-                    bank_toml.bank.name
-                );
-                continue;
-            }
-        };
-
-        let is_latest = if latest_version.version == bank_toml.bank.version {
-            "✅"
-        } else {
-            "❗"
-        };
-
-        println!(" ");
-        println!("📦 {}", bank_toml.bank.name);
-        println!(
-            "  - Version: v{} {} (latest: v{})",
-            bank_toml.bank.version, is_latest, latest_version.version
-        );
-        println!("  - Description: {}", bank_toml.bank.description);
-        println!("  - Author: {}", bank_toml.bank.author);
-    }
-
-    Ok(())
-}
-
-async fn fetch_latest_version(
-    bank_name: String,
-) -> Result<BankVersion, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/{}/version", cdn_url, bank_name);
-
-    let response = reqwest::get(url).await?;
-
-    if !response.status().is_success() {
-        return Err(format!("❌ Failed to fetch version: HTTP {}", response.status()).into());
-    }
-
-    let bytes = response.bytes().await?;
-
-    let version: BankVersion = serde_json::from_slice(&bytes)?;
-
-    Ok(version)
-}
-
-async fn list_external_banks() -> Result<Vec<BankInfo>, Box<dyn std::error::Error>> {
-    let cdn_url = get_cdn_url();
-    let url = format!("{}/bank/list", cdn_url);
-
-    let response = reqwest::get(url).await?;
-
-    if !response.status().is_success() {
-        return Err(format!("❌ Failed to fetch bank list: HTTP {}", response.status()).into());
-    }
-
-    let bytes = response.bytes().await?;
-
-    let parsed: BankList = serde_json::from_slice(&bytes)?;
-
-    Ok(parsed.bank)
-}
-
-async fn list_installed_banks() -> Result<Vec<BankFile>, String> {
-    let deva_dir = std::path::Path::new("./.deva");
-    let bank_dir = deva_dir.join("bank");
-
-    let mut banks = Vec::new();
-
-    if !bank_dir.exists() {
-        return Ok(banks); // No banks installed
-    }
-
-    // TODO: Verify installed banks in files
-    // let installed_banks = std::fs
-    //     ::read_dir(bank_dir)
-    //     .map_err(|e| format!("Failed to read bank directory: {}", e))?;
-
-    let root_dir = deva_dir
-        .parent()
-        .ok_or_else(|| "Failed to determine root directory".to_string())?;
-
-    let config_path = root_dir.join(".devalang");
-    if !config_path.exists() {
-        return Err(format!(
-            "Config file not found at '{}'. Please run 'devalang init' before adding an addon",
-            config_path.display()
-        ));
-    }
-
-    let config = load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    let config_banks = config.banks.clone();
-
-    if let Some(banks_in_toml) = config_banks {
-        for bank in banks_in_toml {
-            let bank_name = bank
-                .path
-                .strip_prefix("devalang://bank/")
-                .unwrap_or(&bank.path)
-                .to_string();
-
-            let bank_path = bank_dir.join(&bank_name);
-            if bank_path.exists() {
-                let bank_info_path = bank_path.join("bank.toml");
-
-                if bank_info_path.exists() {
-                    let content = std::fs::read_to_string(&bank_info_path)
-                        .map_err(|e| format!("Failed to read bank info: {}", e))?;
-
-                    match toml::from_str::<BankFile>(&content) {
-                        Ok(bank_info) => banks.push(bank_info),
-                        Err(_err) => {
-                            eprintln!("❌ Error parsing bank info for '{}'", bank_name);
-                        }
-                    }
-                } else {
-                    eprintln!("❌ Bank info file not found for '{}'", bank_name);
-                }
-            }
-        }
-    }
-
-    Ok(banks)
-}