slicejs-cli 2.5.0 → 2.6.0

package/README.md

@@ -110,8 +110,11 @@ slice registry sync       → slice sync
 slice version
 slice -v
 
-# Check for available updates
-slice update
+# Update CLI and Framework
+slice update              # Check and prompt for updates
+slice update --yes        # Update all automatically
+slice update --cli        # Update only CLI
+slice update --framework  # Update only Framework
 
 # Show help
 slice --help

package/client.js

@@ -9,6 +9,7 @@ import getComponent, { listComponents as listRemoteComponents, syncComponents }
 import startServer from "./commands/startServer/startServer.js";
 import runDiagnostics from "./commands/doctor/doctor.js";
 import versionChecker from "./commands/utils/versionChecker.js";
+import updateManager from "./commands/utils/updateManager.js";
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -340,25 +341,12 @@ sliceClient
 sliceClient
   .command("update")
   .alias("upgrade")
-  .description("Check for and show available updates for CLI and framework")
-  .action(async () => {
-    Print.info("Checking for updates...");
-
-    try {
-      const updateInfo = await versionChecker.checkForUpdates(false);
-
-      if (updateInfo) {
-        if (updateInfo.cli.status === 'current' && updateInfo.framework.status === 'current') {
-          Print.success("All components are up to date!");
-        } else {
-          Print.info("Updates available - see details above");
-        }
-      } else {
-        Print.error("Could not check for updates. Please check your internet connection");
-      }
-    } catch (error) {
-      Print.error(`Checking updates: ${error.message}`);
-    }
+  .description("Update CLI and framework to latest versions")
+  .option("-y, --yes", "Skip confirmation and update all packages automatically")
+  .option("--cli", "Update only the Slice.js CLI")
+  .option("-f, --framework", "Update only the Slice.js Framework")
+  .action(async (options) => {
+    await updateManager.checkAndPromptUpdates(options);
   });
 
 // DOCTOR COMMAND - Diagnose project issues

package/commands/doctor/doctor.js

@@ -34,8 +34,9 @@ async function checkNodeVersion() {
  * Verifica la estructura de directorios
  */
 async function checkDirectoryStructure() {
-    const srcPath = path.join(process.cwd(), 'src');
-    const apiPath = path.join(process.cwd(), 'api');
+    const projectRoot = path.join(__dirname, '../../../../');
+    const srcPath = path.join(projectRoot, 'src');
+    const apiPath = path.join(projectRoot, 'api');
 
     const srcExists = await fs.pathExists(srcPath);
     const apiExists = await fs.pathExists(apiPath);
@@ -62,7 +63,7 @@ async function checkDirectoryStructure() {
  * Verifica sliceConfig.json
  */
 async function checkConfig() {
-    const configPath = path.join(process.cwd(), 'src', 'sliceConfig.json');
+    const configPath = path.join(__dirname, '../../../../src/sliceConfig.json');
 
     if (!await fs.pathExists(configPath)) {
         return {
@@ -100,7 +101,7 @@ async function checkConfig() {
  * Verifica disponibilidad del puerto
  */
 async function checkPort() {
-    const configPath = path.join(process.cwd(), 'src', 'sliceConfig.json');
+    const configPath = path.join(__dirname, '../../../../src/sliceConfig.json');
     let port = 3000;
 
     try {
@@ -144,7 +145,7 @@ async function checkPort() {
  * Verifica dependencias en package.json
  */
 async function checkDependencies() {
-    const packagePath = path.join(process.cwd(), 'package.json');
+    const packagePath = path.join(__dirname, '../../../../package.json');
 
     if (!await fs.pathExists(packagePath)) {
         return {
@@ -188,7 +189,8 @@ async function checkDependencies() {
  * Verifica integridad de componentes
  */
 async function checkComponents() {
-    const configPath = path.join(process.cwd(), 'src', 'sliceConfig.json');
+    const configPath = path.join(__dirname, '../../../../src/sliceConfig.json');
+    const projectRoot = path.join(__dirname, '../../../../');
 
     if (!await fs.pathExists(configPath)) {
         return {
@@ -206,7 +208,7 @@ async function checkComponents() {
         let componentIssues = 0;
 
         for (const [category, { path: compPath }] of Object.entries(componentPaths)) {
-            const fullPath = path.join(process.cwd(), 'src', compPath);
+            const fullPath = path.join(projectRoot, 'src', compPath);
 
             if (await fs.pathExists(fullPath)) {
                 const items = await fs.readdir(fullPath);

package/commands/utils/updateManager.js

@@ -0,0 +1,277 @@
+// commands/utils/updateManager.js
+
+import { exec } from "child_process";
+import { promisify } from "util";
+import inquirer from "inquirer";
+import ora from "ora";
+import Print from "../Print.js";
+import versionChecker from "./versionChecker.js";
+
+const execAsync = promisify(exec);
+
+class UpdateManager {
+    constructor() {
+        this.packagesToUpdate = [];
+    }
+
+    /**
+     * Check for available updates and return structured info
+     */
+    async checkForUpdates() {
+        try {
+            const updateInfo = await versionChecker.checkForUpdates(true); // Silent mode
+
+            if (!updateInfo) {
+                return null;
+            }
+
+            const updates = [];
+
+            if (updateInfo.cli.status === 'outdated') {
+                updates.push({
+                    name: 'slicejs-cli',
+                    displayName: 'Slice.js CLI',
+                    current: updateInfo.cli.current,
+                    latest: updateInfo.cli.latest,
+                    type: 'cli'
+                });
+            }
+
+            if (updateInfo.framework.status === 'outdated') {
+                updates.push({
+                    name: 'slicejs-web-framework',
+                    displayName: 'Slice.js Framework',
+                    current: updateInfo.framework.current,
+                    latest: updateInfo.framework.latest,
+                    type: 'framework'
+                });
+            }
+
+            return {
+                hasUpdates: updates.length > 0,
+                updates,
+                allCurrent: updateInfo.cli.status === 'current' && updateInfo.framework.status === 'current'
+            };
+        } catch (error) {
+            Print.error(`Checking for updates: ${error.message}`);
+            return null;
+        }
+    }
+
+    /**
+     * Display available updates in a formatted way
+     */
+    displayUpdates(updateInfo) {
+        if (!updateInfo || !updateInfo.hasUpdates) {
+            return;
+        }
+
+        console.log('');
+        Print.warning('📦 Actualizaciones Disponibles:');
+        console.log('');
+
+        updateInfo.updates.forEach(pkg => {
+            console.log(`   ${pkg.type === 'cli' ? '🔧' : '⚡'} ${pkg.displayName}`);
+            console.log(`      ${pkg.current} → ${pkg.latest}`);
+        });
+
+        console.log('');
+        console.log('   📚 Changelog: https://github.com/VKneider/slice.js/releases');
+        console.log('');
+    }
+
+    /**
+     * Prompt user to select which packages to update
+     */
+    async promptForUpdates(updateInfo, options = {}) {
+        if (!updateInfo || !updateInfo.hasUpdates) {
+            return [];
+        }
+
+        // If --yes flag is set, return all updates
+        if (options.yes) {
+            return updateInfo.updates.map(pkg => pkg.name);
+        }
+
+        // If specific package flags are set
+        if (options.cli || options.framework) {
+            const selected = [];
+            if (options.cli) {
+                const cliUpdate = updateInfo.updates.find(pkg => pkg.type === 'cli');
+                if (cliUpdate) selected.push(cliUpdate.name);
+            }
+            if (options.framework) {
+                const frameworkUpdate = updateInfo.updates.find(pkg => pkg.type === 'framework');
+                if (frameworkUpdate) selected.push(frameworkUpdate.name);
+            }
+            return selected;
+        }
+
+        // Interactive selection
+        const choices = updateInfo.updates.map(pkg => ({
+            name: `${pkg.displayName} (${pkg.current} → ${pkg.latest})`,
+            value: pkg.name,
+            checked: true
+        }));
+
+        const answers = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'packages',
+                message: '¿Qué paquetes deseas actualizar?',
+                choices,
+                validate: (answer) => {
+                    if (answer.length === 0) {
+                        return 'Debes seleccionar al menos un paquete';
+                    }
+                    return true;
+                }
+            }
+        ]);
+
+        return answers.packages;
+    }
+
+    /**
+     * Execute npm update command for a specific package
+     */
+    async updatePackage(packageName) {
+        try {
+            const command = `npm install ${packageName}@latest`;
+            const { stdout, stderr } = await execAsync(command);
+
+            return {
+                success: true,
+                packageName,
+                stdout,
+                stderr
+            };
+        } catch (error) {
+            return {
+                success: false,
+                packageName,
+                error: error.message
+            };
+        }
+    }
+
+    /**
+     * Update multiple packages with progress indication
+     */
+    async installUpdates(packages) {
+        const results = [];
+
+        for (const packageName of packages) {
+            const spinner = ora(`Actualizando ${packageName}...`).start();
+
+            try {
+                const result = await this.updatePackage(packageName);
+
+                if (result.success) {
+                    spinner.succeed(`${packageName} actualizado exitosamente`);
+                    results.push({ packageName, success: true });
+                } else {
+                    spinner.fail(`Error actualizando ${packageName}`);
+                    Print.error(`Detalles: ${result.error}`);
+                    results.push({ packageName, success: false, error: result.error });
+                }
+            } catch (error) {
+                spinner.fail(`Error actualizando ${packageName}`);
+                Print.error(`Detalles: ${error.message}`);
+                results.push({ packageName, success: false, error: error.message });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Main method to check and prompt for updates
+     */
+    async checkAndPromptUpdates(options = {}) {
+        const spinner = ora('Verificando actualizaciones...').start();
+
+        try {
+            const updateInfo = await this.checkForUpdates();
+            spinner.stop();
+
+            if (!updateInfo) {
+                Print.error('No se pudo verificar actualizaciones. Verifica tu conexión a internet.');
+                return false;
+            }
+
+            if (updateInfo.allCurrent) {
+                Print.success('✅ Todos los componentes están actualizados!');
+                return true;
+            }
+
+            if (!updateInfo.hasUpdates) {
+                Print.success('✅ Todos los componentes están actualizados!');
+                return true;
+            }
+
+            // Display available updates
+            this.displayUpdates(updateInfo);
+
+            // Get packages to update
+            const packagesToUpdate = await this.promptForUpdates(updateInfo, options);
+
+            if (!packagesToUpdate || packagesToUpdate.length === 0) {
+                Print.info('No se seleccionaron paquetes para actualizar.');
+                return false;
+            }
+
+            // Confirm installation if not auto-confirmed
+            if (!options.yes && !options.cli && !options.framework) {
+                const { confirm } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: '¿Deseas continuar con la actualización?',
+                        default: true
+                    }
+                ]);
+
+                if (!confirm) {
+                    Print.info('Actualización cancelada.');
+                    return false;
+                }
+            }
+
+            console.log(''); // Line break
+            Print.info('📥 Instalando actualizaciones...');
+            console.log('');
+
+            // Install updates
+            const results = await this.installUpdates(packagesToUpdate);
+
+            // Summary
+            console.log('');
+            const successCount = results.filter(r => r.success).length;
+            const failCount = results.filter(r => !r.success).length;
+
+            if (failCount === 0) {
+                Print.success(`✅ ${successCount} paquete(s) actualizado(s) exitosamente!`);
+            } else {
+                Print.warning(`⚠️  ${successCount} exitoso(s), ${failCount} fallido(s)`);
+            }
+
+            if (successCount > 0) {
+                console.log('');
+                Print.info('💡 Se recomienda reiniciar el servidor de desarrollo si está ejecutándose.');
+            }
+
+            return failCount === 0;
+
+        } catch (error) {
+            spinner.stop();
+            Print.error(`Error durante la actualización: ${error.message}`);
+            return false;
+        }
+    }
+}
+
+// Singleton instance
+const updateManager = new UpdateManager();
+
+export default updateManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slicejs-cli",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Command client for developing web applications with Slice.js framework",
   "main": "client.js",
   "bin": {