@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/cli/check/mod.rs

@@ -1,208 +0,0 @@
-use crate::{
-    config::driver::ProjectConfig,
-    core::{
-        debugger::{
-            lexer::write_lexer_log_file,
-            logs::{write_module_function_log_file, write_module_variable_log_file},
-            preprocessor::write_preprocessor_log_file,
-            store::{write_function_log_file, write_variables_log_file},
-        },
-        preprocessor::loader::ModuleLoader,
-        store::global::GlobalStore,
-    },
-};
-use devalang_utils::path::{find_entry_file, normalize_path};
-
-use devalang_utils::{
-    logger::{LogLevel, Logger},
-    spinner::start_spinner,
-    watcher::watch_directory,
-};
-
-#[cfg(feature = "cli")]
-pub fn handle_check_command(
-    config: Option<ProjectConfig>,
-    entry: Option<String>,
-    output: Option<String>,
-    watch: bool,
-    debug: bool,
-) -> Result<(), String> {
-    let fetched_entry = if entry.is_none() {
-        config
-            .as_ref()
-            .and_then(|c| c.defaults.entry.clone())
-            .unwrap_or_default()
-    } else {
-        entry.clone().unwrap_or_default()
-    };
-
-    let fetched_output = if output.is_none() {
-        config
-            .as_ref()
-            .and_then(|c| c.defaults.output.clone())
-            .unwrap_or_default()
-    } else {
-        output.clone().unwrap_or_default()
-    };
-
-    let fetched_watch = if watch {
-        watch
-    } else {
-        config
-            .as_ref()
-            .and_then(|c| c.defaults.watch)
-            .unwrap_or(false)
-    };
-
-    let logger = Logger::new();
-
-    if fetched_entry.is_empty() {
-        logger.log_message(
-            LogLevel::Error,
-            "Entry path is not specified. Please provide a valid entry path.",
-        );
-        return Err("missing entry path".to_string());
-    }
-    if fetched_output.is_empty() {
-        logger.log_message(
-            LogLevel::Error,
-            "Output directory is not specified. Please provide a valid output directory.",
-        );
-        return Err("missing output directory".to_string());
-    }
-
-    let entry_file = match find_entry_file(&fetched_entry) {
-        Some(p) => p,
-        None => {
-            logger.log_message(
-                LogLevel::Error,
-                &format!("❌ index.deva not found in directory: {}", fetched_entry),
-            );
-            return Err("index.deva not found".to_string());
-        }
-    };
-
-    // SECTION Begin check
-    if fetched_watch {
-        let _ = begin_check(
-            entry_file.clone(),
-            fetched_output.clone(),
-            debug,
-            config.clone(),
-        );
-
-        logger.log_message(
-            LogLevel::Watcher,
-            &format!("Watching for changes in '{}'...", fetched_entry),
-        );
-
-        let cfg_for_watch = config.clone();
-        watch_directory(entry_file.clone(), move || {
-            logger.log_message(LogLevel::Watcher, "Detected changes, re-checking...");
-            if let Err(e) = begin_check(
-                entry_file.clone(),
-                fetched_output.clone(),
-                debug,
-                cfg_for_watch.clone(),
-            ) {
-                eprintln!("[check] failed: {}", e);
-            }
-        })
-        .unwrap();
-    } else {
-        begin_check(
-            entry_file.clone(),
-            fetched_output.clone(),
-            debug,
-            config.clone(),
-        )?;
-    }
-    Ok(())
-}
-
-fn begin_check(
-    entry: String,
-    output: String,
-    debug: bool,
-    _config: Option<ProjectConfig>,
-) -> Result<(), String> {
-    let spinner = start_spinner("Checking...");
-
-    let duration = std::time::Instant::now();
-
-    let normalized_entry_file = normalize_path(&entry);
-    let normalized_output_dir = normalize_path(&output);
-
-    let mut global_store = GlobalStore::new();
-    let module_loader = ModuleLoader::new(&normalized_entry_file, &normalized_output_dir);
-
-    // SECTION Load
-    // NOTE: We don't use modules in the check command, but we still need to load them
-    let modules = module_loader.load_all_modules(&mut global_store);
-
-    // Debugging: Log loaded modules and errors
-    let logger = Logger::new();
-    logger.log_message(LogLevel::Info, "Loaded modules:");
-    for module_name in modules.0.keys() {
-        logger.log_message(LogLevel::Info, &format!("- {}", module_name));
-    }
-
-    if debug {
-        for (module_path, module) in global_store.modules.clone() {
-            write_module_variable_log_file(
-                &normalized_output_dir,
-                &module_path,
-                &module.variable_table,
-            );
-            write_module_function_log_file(
-                &normalized_output_dir,
-                &module_path,
-                &module.function_table,
-            );
-        }
-
-        write_lexer_log_file(
-            &normalized_output_dir,
-            "lexer_tokens.log",
-            modules.0.clone(),
-        );
-        write_preprocessor_log_file(
-            &normalized_output_dir,
-            "resolved_statements.log",
-            modules.1.clone(),
-        );
-        write_variables_log_file(
-            &normalized_output_dir,
-            "global_variables.log",
-            global_store.variables.clone(),
-        );
-        write_function_log_file(
-            &normalized_output_dir,
-            "global_functions.log",
-            global_store.functions.clone(),
-        );
-    }
-
-    let all_errors = crate::core::error::collect_all_errors_with_modules(&modules.1);
-
-    let (warnings, criticals) = crate::core::error::partition_errors(all_errors);
-    crate::core::error::log_errors_with_stack("Check", &warnings, &criticals);
-
-    if !criticals.is_empty() {
-        spinner.finish_and_clear();
-        return Err("check failed with critical errors".to_string());
-    } else {
-        logger.log_message(LogLevel::Success, "No errors detected.");
-
-        let success_message = format!(
-            "Check completed successfully in {:.2?}. Output files written to: '{}'",
-            duration.elapsed(),
-            normalized_output_dir
-        );
-
-        spinner.finish_and_clear();
-        logger.log_message(LogLevel::Success, &success_message);
-    }
-
-    Ok(())
-}

package/rust/cli/discover/commands.rs

@@ -1,253 +0,0 @@
-use crate::cli::discover::config::add_addons_to_config;
-use crate::cli::discover::install::install_selected_addons;
-use devalang_types::DiscoveredAddon;
-use devalang_utils::{
-    logger::{LogLevel, Logger},
-    path as path_utils,
-    spinner::start_spinner,
-};
-
-pub async fn handle_discover_command() -> Result<(), String> {
-    let deva_dir = path_utils::ensure_deva_dir()?;
-
-    // Search for addons (banks, plugins, presets, templates) in the .deva directory
-    let valid_addons_extensions = ["devabank", "devaplugin", "devapreset", "devatemplate"];
-
-    let mut addons_found = Vec::new();
-
-    // Recursively walk the .deva directory and collect addon files matching
-    // the known addon extensions. This allows discovery in nested folders.
-    fn walk_dir_collect(base: &std::path::Path, exts: &[&str], out: &mut Vec<DiscoveredAddon>) {
-        if let Ok(entries) = std::fs::read_dir(base) {
-            for entry in entries.filter_map(|e| e.ok()) {
-                let p = entry.path();
-                if p.is_dir() {
-                    walk_dir_collect(&p, exts, out);
-                } else if p.is_file() {
-                    if let Some(ext) = p.extension().and_then(|s| s.to_str()) {
-                        if exts.contains(&ext) {
-                            let name = p
-                                .file_stem()
-                                .map(|s| s.to_string_lossy().to_string())
-                                .unwrap_or_default();
-                            let addon_type = match ext {
-                                "devabank" => "bank",
-                                "devaplugin" => "plugin",
-                                "devapreset" => "preset",
-                                "devatemplate" => "template",
-                                _ => "unknown",
-                            };
-
-                            out.push(DiscoveredAddon {
-                                path: p.clone(),
-                                name,
-                                extension: ext.to_string(),
-                                addon_type: addon_type.to_string(),
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    walk_dir_collect(&deva_dir, &valid_addons_extensions, &mut addons_found);
-
-    let logger = Logger::new();
-
-    let banks_found = addons_found
-        .iter()
-        .filter(|addon| addon.addon_type == "bank")
-        .cloned()
-        .collect::<Vec<_>>();
-
-    let plugins_found = addons_found
-        .iter()
-        .filter(|addon| addon.addon_type == "plugin")
-        .cloned()
-        .collect::<Vec<_>>();
-
-    let presets_found = addons_found
-        .iter()
-        .filter(|addon| addon.addon_type == "preset")
-        .cloned()
-        .collect::<Vec<_>>();
-
-    let templates_found = addons_found
-        .iter()
-        .filter(|addon| addon.addon_type == "template")
-        .cloned()
-        .collect::<Vec<_>>();
-
-    let mut all_addons = Vec::with_capacity(
-        banks_found.len() + plugins_found.len() + presets_found.len() + templates_found.len(),
-    );
-    all_addons.extend(banks_found.iter().cloned());
-    all_addons.extend(plugins_found.iter().cloned());
-    all_addons.extend(presets_found.iter().cloned());
-    all_addons.extend(templates_found.iter().cloned());
-
-    println!();
-
-    if all_addons.is_empty() {
-        logger.log_message(LogLevel::Error, "No addons found in the '.deva' folder");
-        return Ok(());
-    }
-
-    if !banks_found.is_empty() {
-        let mut bank_traces: Vec<String> = Vec::new();
-
-        for addon in &banks_found {
-            bank_traces.push(addon.name.to_string());
-        }
-
-        let trace_refs: Vec<&str> = bank_traces.iter().map(|s| s.as_str()).collect();
-
-        logger.log_message_with_trace(
-            LogLevel::Info,
-            format!("Found {} compiled banks in workspace", banks_found.len()).as_str(),
-            trace_refs,
-        );
-    }
-
-    if !plugins_found.is_empty() {
-        let mut plugin_traces: Vec<String> = Vec::new();
-
-        for addon in &plugins_found {
-            plugin_traces.push(addon.name.to_string());
-        }
-
-        let trace_refs: Vec<&str> = plugin_traces.iter().map(|s| s.as_str()).collect();
-
-        logger.log_message_with_trace(
-            LogLevel::Info,
-            format!(
-                "Found {} compiled plugins in workspace",
-                plugins_found.len()
-            )
-            .as_str(),
-            trace_refs,
-        );
-    }
-
-    if !presets_found.is_empty() {
-        let mut preset_traces: Vec<String> = Vec::new();
-
-        for addon in &presets_found {
-            preset_traces.push(addon.name.to_string());
-        }
-
-        let trace_refs: Vec<&str> = preset_traces.iter().map(|s| s.as_str()).collect();
-
-        logger.log_message_with_trace(
-            LogLevel::Info,
-            format!(
-                "Found {} compiled presets in workspace",
-                presets_found.len()
-            )
-            .as_str(),
-            trace_refs,
-        );
-    }
-
-    if !templates_found.is_empty() {
-        let mut template_traces: Vec<String> = Vec::new();
-
-        for addon in &templates_found {
-            template_traces.push(addon.name.to_string());
-        }
-
-        let trace_refs: Vec<&str> = template_traces.iter().map(|s| s.as_str()).collect();
-
-        logger.log_message_with_trace(
-            LogLevel::Info,
-            format!(
-                "Found {} compiled templates in workspace",
-                templates_found.len()
-            )
-            .as_str(),
-            trace_refs,
-        );
-    }
-
-    println!();
-
-    // Build user-friendly, unique labels tied to each addon by including the path
-    let choice_labels: Vec<String> = all_addons
-        .iter()
-        .map(|addon| {
-            format!(
-                "{}: {} ({})",
-                addon.addon_type,
-                addon.name,
-                addon.path.display()
-            )
-        })
-        .collect();
-
-    let selected_addons = match inquire::MultiSelect::new(
-        "Select addons to install:",
-        choice_labels.clone(),
-    )
-    .prompt()
-    {
-        Ok(selected_addons) => selected_addons,
-        Err(err) => {
-            logger.log_message(
-                LogLevel::Error,
-                format!("Error selecting addons: {}", err).as_str(),
-            );
-
-            return Err(format!("Error selecting addons: {}", err));
-        }
-    };
-
-    let spinner = start_spinner("Installing addons...");
-
-    let addons_to_install = selected_addons
-        .iter()
-        .filter_map(|label| {
-            all_addons.iter().find(|addon| {
-                let candidate = format!(
-                    "{}: {} ({})",
-                    addon.addon_type,
-                    addon.name,
-                    addon.path.display()
-                );
-                &candidate == label
-            })
-        })
-        .cloned()
-        .collect::<Vec<_>>();
-
-    let install_selected_addons_result = install_selected_addons(addons_to_install).await;
-    match install_selected_addons_result {
-        Ok(addons_enriched) => {
-            if let Err(e) = add_addons_to_config(addons_enriched).await {
-                spinner.finish_and_clear();
-                logger.log_message(
-                    LogLevel::Error,
-                    format!("Failed to add addons to config: {}", e).as_str(),
-                );
-                return Err(format!("Failed to add addons to config: {}", e));
-            }
-
-            spinner.finish_and_clear();
-            println!();
-            logger.log_message(
-                LogLevel::Success,
-                "Successfully installed addons !".to_string().as_str(),
-            );
-        }
-        Err(e) => {
-            spinner.finish_and_clear();
-            logger.log_message(
-                LogLevel::Error,
-                format!("Failed to install addons: {}", e).as_str(),
-            );
-            return Err(format!("Failed to install addons: {}", e));
-        }
-    }
-
-    Ok(())
-}

package/rust/cli/discover/config.rs

@@ -1,111 +0,0 @@
-use devalang_core::config::driver::ProjectConfigExt;
-use devalang_types::{AddonWithMetadata, ProjectConfigBankEntry, ProjectConfigPluginEntry};
-use devalang_utils::path as path_utils;
-
-pub async fn add_addons_to_config(addons: Vec<AddonWithMetadata>) -> Result<(), String> {
-    let config_path = path_utils::get_devalang_config_path()?;
-    let mut config = crate::config::ops::load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    for addon in addons {
-        let addon_path_as_devalang_protocol = format!(
-            "devalang://{}/{}.{}",
-            addon.addon_type, addon.metadata.author, addon.metadata.name
-        );
-
-        match addon.addon_type.as_str() {
-            "bank" => {
-                if config.banks.is_none() {
-                    config.banks = Some(Vec::new());
-                }
-
-                let banks = config.banks.as_mut().unwrap();
-
-                let exists = banks
-                    .iter()
-                    .any(|b| b.path == addon_path_as_devalang_protocol);
-                if exists {
-                    println!("Bank '{}' already in config", addon.name);
-                    continue;
-                }
-
-                banks.push(ProjectConfigBankEntry {
-                    path: addon_path_as_devalang_protocol,
-                    version: Some(addon.metadata.version.clone()),
-                });
-            }
-
-            "plugin" => {
-                if config.plugins.is_none() {
-                    config.plugins = Some(Vec::new());
-                }
-
-                let plugins = config.plugins.as_mut().unwrap();
-
-                let exists = plugins
-                    .iter()
-                    .any(|p| p.path == addon_path_as_devalang_protocol);
-                if exists {
-                    println!("Plugin '{}' already in config", addon.name);
-                    continue;
-                }
-
-                plugins.push(ProjectConfigPluginEntry {
-                    path: addon_path_as_devalang_protocol,
-                    version: Some(addon.metadata.version.clone()),
-                });
-            }
-
-            // "preset" => {
-            //     if config.presets.is_none() {
-            //         config.presets = Some(Vec::new());
-            //     }
-
-            //     let presets = config.presets.as_mut().unwrap();
-
-            //     let exists = presets.iter().any(|p| p.path == addon_path_as_deva_protocol);
-            //     if exists {
-            //         println!("Preset '{}' already in config", addon.name);
-            //         continue;
-            //     }
-
-            //     presets.push(ProjectConfigPresetEntry {
-            //         path: addon_path_as_deva_protocol,
-            //         version: Some(addon.metadata.version.clone()),
-            //     });
-            // }
-
-            // "template" => {
-            //     if config.templates.is_none() {
-            //         config.templates = Some(Vec::new());
-            //     }
-
-            //     let templates = config.templates.as_mut().unwrap();
-
-            //     let exists = templates.iter().any(|t| t.path == addon_path_as_deva_protocol);
-            //     if exists {
-            //         println!("Template '{}' already in config", addon.name);
-            //         continue;
-            //     }
-
-            //     templates.push(ProjectConfigTemplateEntry {
-            //         path: addon_path_as_deva_protocol,
-            //         version: Some(addon.metadata.version.clone()),
-            //     });
-            // }
-            _ => {
-                println!(
-                    "Unknown addon type '{}' for addon '{}'",
-                    addon.addon_type, addon.name
-                );
-            }
-        }
-    }
-
-    // Update config with new addons
-    if let Err(e) = config.write_config(&config) {
-        return Err(format!("Failed to write config: {}", e));
-    }
-
-    Ok(())
-}

package/rust/cli/discover/fs.rs

@@ -1,19 +0,0 @@
-use std::{fs, io, path::Path};
-
-pub fn copy_dir_all(src: &Path, dst: &Path) -> Result<(), io::Error> {
-    if !dst.exists() {
-        fs::create_dir_all(dst)?;
-    }
-    for entry in fs::read_dir(src)? {
-        let entry = entry?;
-        let ty = entry.file_type()?;
-        let from = entry.path();
-        let to = dst.join(entry.file_name());
-        if ty.is_dir() {
-            copy_dir_all(&from, &to)?;
-        } else {
-            fs::copy(&from, &to)?;
-        }
-    }
-    Ok(())
-}

package/rust/cli/discover/install.rs

@@ -1,103 +0,0 @@
-use devalang_types::{AddonMetadata, AddonWithMetadata, DiscoveredAddon};
-use devalang_utils::path as path_utils;
-
-pub async fn install_selected_addons(
-    addons: Vec<DiscoveredAddon>,
-) -> Result<Vec<AddonWithMetadata>, String> {
-    let mut addons_enriched = Vec::new();
-
-    let tmp_dir = path_utils::ensure_deva_dir()?.join("tmp");
-
-    for addon in addons {
-        std::fs::create_dir_all(tmp_dir.join(&addon.name))
-            .map_err(|e| format!("Failed to create directory for addon {}: {}", addon.name, e))?;
-
-        let addon_path = tmp_dir.join(&addon.name);
-        devalang_utils::file::extract_zip_safely(&addon.path, &addon_path)
-            .map_err(|e| format!("Failed to extract addon {}: {}", addon.name, e))?;
-
-        let base = path_utils::ensure_deva_dir()?;
-        let target_addon_dir = match addon.addon_type.as_str() {
-            "bank" => base.join("banks"),
-            "plugin" => base.join("plugins"),
-            "preset" => base.join("presets"),
-            "template" => base.join("templates"),
-            _ => {
-                return Err(format!("Unknown addon type for addon {}", addon.name));
-            }
-        };
-
-        std::fs::create_dir_all(&target_addon_dir).map_err(|e| {
-            format!(
-                "Failed to create target directory for addon {}: {}",
-                addon.name, e
-            )
-        })?;
-
-        let target_addon_path_dir = target_addon_dir.join(&addon.name);
-        if target_addon_path_dir.exists() {
-            println!(
-                "Target addon directory {} already exists",
-                target_addon_path_dir.display()
-            );
-            continue;
-        }
-
-        if let Err(e) = std::fs::rename(&addon_path, &target_addon_path_dir) {
-            crate::cli::discover::fs::copy_dir_all(&addon_path, &target_addon_path_dir).map_err(
-                |err| {
-                    format!(
-                        "Failed to move addon {}: {} (rename error: {})",
-                        addon.name, err, e
-                    )
-                },
-            )?;
-            let _ = std::fs::remove_dir_all(&addon_path);
-        }
-
-        let addon_metadata_filename = match addon.addon_type.as_str() {
-            "bank" => "bank.toml",
-            "plugin" => "plugin.toml",
-            "preset" => "preset.toml",
-            "template" => "template.toml",
-            _ => {
-                return Err(format!("Unknown addon type for addon {}", addon.name));
-            }
-        };
-
-        let addon_metadata_path = target_addon_path_dir.join(addon_metadata_filename);
-        let addon_metadata_content = std::fs::read_to_string(&addon_metadata_path)
-            .map_err(|e| format!("Failed to read metadata for addon {}: {}", addon.name, e))?;
-
-        let parsed_meta = crate::cli::discover::metadata::parse_metadata_file(
-            &addon.addon_type,
-            &addon_metadata_content,
-        )
-        .unwrap_or(AddonMetadata {
-            name: addon.name.clone(),
-            author: "unknown".to_string(),
-            version: "".to_string(),
-            description: "".to_string(),
-            access: "".to_string(),
-        });
-
-        addons_enriched.push(AddonWithMetadata {
-            name: addon.name.clone(),
-            path: addon.path.clone().to_string_lossy().to_string(),
-            addon_type: addon.addon_type.clone(),
-            metadata: parsed_meta,
-        });
-
-        if let Err(e) = std::fs::remove_file(&addon.path) {
-            eprintln!(
-                "Failed to remove zipped file for addon {}: {}",
-                addon.name, e
-            );
-        }
-    }
-
-    // Best-effort cleanup of temporary extraction directory
-    let _ = std::fs::remove_dir_all(&tmp_dir);
-
-    Ok(addons_enriched)
-}