@ionyx-apps/cli 0.2.0 → 0.3.0

package/ionyx-cli/src/commands/doctor.rs

@@ -0,0 +1,158 @@
+use anyhow::Result;
+use colored::*;
+use std::process::Command;
+use std::path::Path;
+
+pub async fn execute() -> Result<()> {
+    println!("\n{}", "⚕️ Ionyx Doctor - Diagnostic Report".bold().bright_blue());
+    println!("{}", "=====================================".bright_blue());
+
+    let mut issues = 0;
+    let mut warnings = 0;
+
+    // 1. Operating System
+    print_check("Operating System", true, "");
+    let info = os_info::get();
+    println!("   {} {} {} {}", info.os_type(), info.version(), info.bitness(), info.architecture().unwrap_or(""));
+
+    // 2. Rust Environment
+    println!("\n{}", "🦀 Rust Environment".bold());
+    let rustc = check_version("rustc", &["--version"]);
+    let cargo = check_version("cargo", &["--version"]);
+    
+    match (rustc.as_ref(), cargo.as_ref()) {
+        (Some(r), Some(c)) => {
+            print_check("Rust/Cargo", true, "Detected");
+            println!("   rustc: {}", r);
+            println!("   cargo: {}", c);
+        }
+        _ => {
+            if rustc.is_none() { print_check("rustc", false, "Not found"); }
+            if cargo.is_none() { print_check("cargo", false, "Not found"); }
+            println!("   {} Please install Rust from https://rustup.rs", "!".yellow());
+            issues += 1;
+        }
+    }
+
+    // 3. Node Environment
+    println!("\n{}", "🟢 Node.js Environment".bold());
+    let node = check_version("node", &["--version"]);
+    let npm = check_version("npm", &["--version"]);
+    
+    match (node.as_ref(), npm.as_ref()) {
+        (Some(n), Some(m)) => {
+            print_check("Node/NPM", true, "Detected");
+            println!("   node: {}", n);
+            println!("   npm:  {}", m);
+        }
+        _ => {
+            if node.is_none() { print_check("node", false, "Not found"); }
+            if npm.is_none() { print_check("npm", false, "Not found (Ensure it's in your PATH)"); }
+            println!("   {} Please install Node.js from https://nodejs.org", "!".yellow());
+            issues += 1;
+        }
+    }
+
+    // 4. Bundling Tools
+    println!("\n{}", "📦 Bundling Tools".bold());
+    
+    #[cfg(target_os = "windows")]
+    {
+        // NSIS
+        if let Some(v) = check_version("makensis", &["/VERSION"]) {
+            print_check("NSIS (for EXE)", true, &format!("Version {}", v));
+        } else {
+            print_warning("NSIS (for EXE)", "Not found. Required for building .exe installers. Install from https://nsis.sourceforge.io");
+            warnings += 1;
+        }
+
+        // WiX
+        if let Some(_) = check_version("candle", &["-?"]) {
+            print_check("WiX Toolset (for MSI)", true, "Detected");
+        } else {
+            print_warning("WiX Toolset (for MSI)", "Not found. Required for building .msi installers. Install from https://wixtoolset.org");
+            warnings += 1;
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        if let Some(_) = check_version("hdiutil", &["help"]) {
+            print_check("hdiutil (for DMG)", true, "Detected");
+        } else {
+            print_warning("hdiutil (for DMG)", "Not found. Required for building .dmg installers.");
+            warnings += 1;
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        if let Some(_) = check_version("appimagetool", &["--version"]) {
+            print_check("appimagetool (for AppImage)", true, "Detected");
+        } else {
+            print_warning("appimagetool (for AppImage)", "Not found. Required for building .AppImage. Install from https://appimage.org");
+            warnings += 1;
+        }
+    }
+
+    // 5. Project Context
+    println!("\n{}", "🏠 Project Context".bold());
+    if Path::new("ionyx.config.json").exists() || Path::new("ionyx.config.toml").exists() {
+        print_check("Ionyx Project", true, "You are inside an Ionyx project directory.");
+    } else {
+        println!("   {} {}", "!".yellow(), "You are NOT in an Ionyx project directory. Some commands like 'build' or 'dev' will not work.");
+    }
+
+    // Summary
+    println!("\n{}", "Summary".bold());
+    if issues == 0 && warnings == 0 {
+        println!("  {} No issues found! Your environment is perfectly configured for Ionyx. 🚀", "✓".green());
+    } else {
+        if issues > 0 {
+            println!("  {} Found {} critical issue(s). Review the report above for fixes.", "✗".red(), issues);
+        }
+        if warnings > 0 {
+            println!("  {} Found {} warning(s). You can still develop, but some features (like bundling) might be limited.", "!".yellow(), warnings);
+        }
+    }
+
+    println!();
+    Ok(())
+}
+
+fn print_check(title: &str, success: bool, msg: &str) {
+    if success {
+        println!(" {} {}: {}", "✓".green(), title.bold(), msg.dimmed());
+    } else {
+        println!(" {} {}: {}", "✗".red(), title.bold(), msg.bright_red());
+    }
+}
+
+fn print_warning(title: &str, msg: &str) {
+    println!(" {} {}: {}", "!".yellow(), title.bold(), msg.yellow());
+}
+
+fn check_version(cmd: &str, args: &[&str]) -> Option<String> {
+    // Platform specific variations
+    let cmd_variations = if cfg!(target_os = "windows") {
+        match cmd {
+            "npm" => vec!["npm.cmd", "npm"],
+            "makensis" => vec!["makensis.exe", "makensis"],
+            "candle" => vec!["candle.exe", "candle"],
+            _ => vec![cmd],
+        }
+    } else {
+        vec![cmd]
+    };
+
+    for c in cmd_variations {
+        match Command::new(c).args(args).output() {
+            Ok(output) if output.status.success() => {
+                let out = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                return Some(out.lines().next().unwrap_or("").trim().to_string());
+            }
+            _ => continue,
+        }
+    }
+    None
+}

package/ionyx-cli/src/commands/info.rs

@@ -0,0 +1,79 @@
+use anyhow::Result;
+use colored::*;
+use std::process::Command;
+
+pub async fn execute() -> Result<()> {
+    println!("\n{}", "Ionyx Environment".bold().bright_blue());
+
+    println!("\n{}", "Operating System".bold());
+    let info = os_info::get();
+    println!("  {}: {} {} {}", 
+        "OS".green(), 
+        info.os_type(), 
+        info.version(), 
+        info.bitness()
+    );
+    
+    // Get Rust version
+    println!("\n{}", "Rust Environment".bold());
+    let mut rustc_cmd = Command::new("rustc");
+    rustc_cmd.arg("--version");
+    
+    match rustc_cmd.output() {
+        Ok(output) if output.status.success() => {
+            let version = String::from_utf8_lossy(&output.stdout);
+            println!("  {}: {}", "rustc".green(), version.trim());
+        }
+        _ => {
+            println!("  {}: {}", "rustc".red(), "Not installed or not in PATH");
+        }
+    }
+
+    let mut cargo_cmd = Command::new("cargo");
+    cargo_cmd.arg("--version");
+    
+    match cargo_cmd.output() {
+        Ok(output) if output.status.success() => {
+            let version = String::from_utf8_lossy(&output.stdout);
+            println!("  {}: {}", "cargo".green(), version.trim());
+        }
+        _ => {
+            println!("  {}: {}", "cargo".red(), "Not installed or not in PATH");
+        }
+    }
+
+    // Node environment
+    println!("\n{}", "Node Environment".bold());
+    let mut node_cmd = Command::new("node");
+    node_cmd.arg("--version");
+    
+    match node_cmd.output() {
+        Ok(output) if output.status.success() => {
+            let version = String::from_utf8_lossy(&output.stdout);
+            println!("  {}: {}", "node".green(), version.trim());
+        }
+        _ => {
+            println!("  {}: {}", "node".red(), "Not installed or not in PATH");
+        }
+    }
+
+    let mut npm_cmd = Command::new("npm");
+    npm_cmd.arg("--version");
+    
+    match npm_cmd.output() {
+        Ok(output) if output.status.success() => {
+            let version = String::from_utf8_lossy(&output.stdout);
+            println!("  {}: {}", "npm".green(), version.trim());
+        }
+        _ => {
+            println!("  {}: {}", "npm".red(), "Not installed or not in PATH");
+        }
+    }
+
+    // CLI version
+    println!("\n{}", "Ionyx Framework".bold());
+    println!("  {}: {}", "ionyx-cli".green(), env!("CARGO_PKG_VERSION"));
+    
+    println!();
+    Ok(())
+}

package/ionyx-cli/src/commands/init.rs

@@ -0,0 +1,64 @@
+use anyhow::Result;
+use colored::*;
+use crate::templates;
+use std::fs;
+use std::path::Path;
+
+pub async fn execute(mut name: String, template: &str) -> Result<()> {
+    let mut dest_path = name.clone();
+    
+    // Handle current directory initialization
+    if name == "." || name == "./" {
+        name = std::env::current_dir()?
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("my-ionyx-app")
+            .to_string();
+        dest_path = ".".to_string();
+        println!("🚀 Initializing in current directory: {}", name.green());
+    } else {
+        println!("🚀 Creating new Ionyx project: {}", name.green());
+        
+        // Check if directory already exists
+        if Path::new(&dest_path).exists() {
+            return Err(anyhow::anyhow!("Directory '{}' already exists", dest_path));
+        }
+        
+        // Create project directory
+        fs::create_dir_all(&dest_path)?;
+        println!("✅ Created directory: {}", dest_path);
+    }
+    
+    // Show template info
+    println!("📋 Template: {}", template.cyan());
+    
+    // Copy template files
+    templates::copy_template(&name, &dest_path, template).await?;
+    
+    // Show next steps
+    println!("\n✅ Project '{}' created successfully!", name.green());
+    println!("\n📋 Next steps:");
+    println!("   cd {}", name);
+    println!("   npm run ionyx:dev");
+    
+    // Show framework-specific info
+    match template {
+        "react" => println!("\n🎯 React + TypeScript + Vite setup ready!"),
+        "svelte" => println!("\n🎯 Svelte + TypeScript + Vite setup ready!"),
+        "vue" => println!("\n🎯 Vue + TypeScript + Vite setup ready!"),
+        "leptos" => println!("\n🎯 Rust + Leptos (WASM) setup ready!"),
+        "angular" => println!("\n🎯 Angular + TypeScript + Vite setup ready!"),
+        "vanilla" => println!("\n🎯 Vanilla JavaScript + Vite setup ready!"),
+        _ => println!("\n🎯 Basic Ionyx setup ready!"),
+    }
+    
+    println!("\n🚀 Available commands:");
+    println!("   npm run ionyx:dev    # Start Ionyx application");
+    println!("   npm run ionyx:build   # Build for production");
+    println!("   npm run dev           # Frontend only");
+    println!("   npm run build         # Frontend build only");
+    
+    println!("\n🎉 Happy coding with Ionyx Framework!");
+    
+    Ok(())
+}

package/ionyx-cli/src/commands/mod.rs

@@ -0,0 +1,9 @@
+pub mod build;
+pub mod bundle;
+pub mod config;
+pub mod dev;
+pub mod doctor;
+pub mod info;
+pub mod init;
+pub mod plugin;
+pub mod run;

package/ionyx-cli/src/commands/plugin.rs

@@ -0,0 +1,34 @@
+use anyhow::Result;
+use colored::*;
+use std::fs;
+use std::path::Path;
+
+pub async fn execute(action: crate::PluginAction) -> Result<()> {
+    match action {
+        crate::PluginAction::Install { name } => {
+            println!("📦 Installing plugin: {}", name.cyan());
+            
+            // Here you would implement plugin installation logic
+            // For now, just show a message
+            println!("⚠️  Plugin installation not implemented yet");
+        }
+        crate::PluginAction::Uninstall { name } => {
+            println!("🗑️  Uninstalling plugin: {}", name.cyan());
+            
+            // Here you would implement plugin uninstallation logic
+            println!("⚠️  Plugin uninstallation not implemented yet");
+        }
+        crate::PluginAction::List => {
+            println!("📦 Installed plugins:");
+            println!("⚠️  Plugin system not implemented yet");
+        }
+        crate::PluginAction::Update { name } => {
+            println!("🔄 Updating plugin: {}", name.cyan());
+            
+            // Here you would implement plugin update logic
+            println!("⚠️  Plugin update not implemented yet");
+        }
+    }
+    
+    Ok(())
+}

package/ionyx-cli/src/commands/run.rs

@@ -0,0 +1,54 @@
+use anyhow::Result;
+use colored::*;
+use std::process::Command;
+use std::path::Path;
+
+pub async fn execute(port: u16) -> Result<()> {
+    println!("🚀 Running Ionyx application on port {}", port.to_string().cyan());
+    
+    if !Path::new("package.json").exists() {
+        return Err(anyhow::anyhow!("No package.json found. Please run this command in an Ionyx project directory."));
+    }
+    
+    // Check if node_modules exists, if not, install dependencies
+    if !Path::new("node_modules").exists() {
+        println!("📦 Installing dependencies...");
+        let output = Command::new("npm")
+            .arg("install")
+            .output()
+            .expect("Failed to run npm install");
+        
+        println!("{}", String::from_utf8_lossy(&output.stdout));
+    }
+    
+    // Check if build exists, if not, build first
+    if !Path::new("dist").exists() {
+        println!("📦 No build found, building first...");
+        let output = Command::new("npm")
+            .arg("run")
+            .arg("build")
+            .output()
+            .expect("Failed to run build command");
+        
+        println!("{}", String::from_utf8_lossy(&output.stdout));
+    }
+    
+    // Run application
+    let mut cmd = Command::new("npm");
+    cmd.arg("run").arg("start");
+    
+    // Set port if different from default
+    if port != 5173 {
+        cmd.env("PORT", port.to_string());
+    }
+    
+    println!("🌐 Application started at: http://localhost:{}", port);
+    
+    let status = cmd.status()?;
+    
+    if !status.success() {
+        return Err(anyhow::anyhow!("Application failed to start"));
+    }
+    
+    Ok(())
+}

package/ionyx-cli/src/config/mod.rs

@@ -0,0 +1,155 @@
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::Path;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProjectConfig {
+    pub name: String,
+    pub version: String,
+    pub description: String,
+    pub r#type: String,
+    pub src: String,
+    pub dist: String,
+    pub dev: DevConfig,
+    pub build: BuildConfig,
+    pub ionyx: IonyxConfig,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DevConfig {
+    pub port: u16,
+    pub hot: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BuildConfig {
+    pub target: String,
+    pub assets: String,
+    pub minify: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IonyxConfig {
+    pub permissions: Vec<String>,
+    pub security: SecurityConfig,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SecurityConfig {
+    pub allowed_paths: Vec<String>,
+}
+
+impl ProjectConfig {
+    pub fn load() -> Result<Self, anyhow::Error> {
+        let config_path = "ionyx.config.json";
+        
+        if !Path::new(config_path).exists() {
+            return Ok(ProjectConfig::default());
+        }
+        
+        let content = fs::read_to_string(config_path)?;
+        let config: ProjectConfig = serde_json::from_str(&content)?;
+        Ok(config)
+    }
+    
+    pub fn save(&self) -> Result<(), anyhow::Error> {
+        let content = serde_json::to_string_pretty(self)?;
+        fs::write("ionyx.config.json", content)?;
+        Ok(())
+    }
+    
+    pub fn reset() -> Result<(), anyhow::Error> {
+        let default_config = ProjectConfig::default();
+        default_config.save()
+    }
+    
+    pub fn get(&self, key: &str) -> Option<String> {
+        match key {
+            "name" => Some(self.name.clone()),
+            "version" => Some(self.version.clone()),
+            "description" => Some(self.description.clone()),
+            "type" => Some(self.r#type.clone()),
+            "src" => Some(self.src.clone()),
+            "dist" => Some(self.dist.clone()),
+            "dev.port" => Some(self.dev.port.to_string()),
+            "dev.hot" => Some(self.dev.hot.to_string()),
+            "build.target" => Some(self.build.target.clone()),
+            "build.assets" => Some(self.build.assets.clone()),
+            "build.minify" => Some(self.build.minify.to_string()),
+            _ => None,
+        }
+    }
+    
+    pub fn set(&mut self, key: &str, value: &str) {
+        match key {
+            "name" => self.name = value.to_string(),
+            "version" => self.version = value.to_string(),
+            "description" => self.description = value.to_string(),
+            "type" => self.r#type = value.to_string(),
+            "src" => self.src = value.to_string(),
+            "dist" => self.dist = value.to_string(),
+            "dev.port" => {
+                if let Ok(port) = value.parse() {
+                    self.dev.port = port;
+                }
+            }
+            "dev.hot" => {
+                if let Ok(hot) = value.parse() {
+                    self.dev.hot = hot;
+                }
+            }
+            "build.target" => self.build.target = value.to_string(),
+            "build.assets" => self.build.assets = value.to_string(),
+            "build.minify" => {
+                if let Ok(minify) = value.parse() {
+                    self.build.minify = minify;
+                }
+            }
+            _ => {}
+        }
+    }
+    
+    pub fn get_all(&self) -> Vec<(String, String)> {
+        vec![
+            ("name".to_string(), self.name.clone()),
+            ("version".to_string(), self.version.clone()),
+            ("description".to_string(), self.description.clone()),
+            ("type".to_string(), self.r#type.clone()),
+            ("src".to_string(), self.src.clone()),
+            ("dist".to_string(), self.dist.clone()),
+            ("dev.port".to_string(), self.dev.port.to_string()),
+            ("dev.hot".to_string(), self.dev.hot.to_string()),
+            ("build.target".to_string(), self.build.target.clone()),
+            ("build.assets".to_string(), self.build.assets.clone()),
+            ("build.minify".to_string(), self.build.minify.to_string()),
+        ]
+    }
+}
+
+impl Default for ProjectConfig {
+    fn default() -> Self {
+        Self {
+            name: "my-ionyx-app".to_string(),
+            version: "1.0.0".to_string(),
+            description: "Ionyx Framework Application".to_string(),
+            r#type: "app".to_string(),
+            src: "src".to_string(),
+            dist: "dist".to_string(),
+            dev: DevConfig {
+                port: 5173,
+                hot: true,
+            },
+            build: BuildConfig {
+                target: "web".to_string(),
+                assets: "dist".to_string(),
+                minify: false,
+            },
+            ionyx: IonyxConfig {
+                permissions: vec!["fs".to_string(), "network".to_string(), "os_info".to_string()],
+                security: SecurityConfig {
+                    allowed_paths: vec!["./app-data".to_string()],
+                },
+            },
+        }
+    }
+}