slicejs-cli 2.3.3 → 2.5.1

package/commands/doctor/doctor.js

@@ -0,0 +1,335 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createServer } from 'net';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import Print from '../Print.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Verifica la versión de Node.js
+ */
+async function checkNodeVersion() {
+    const currentVersion = process.version;
+    const majorVersion = parseInt(currentVersion.slice(1).split('.')[0]);
+    const required = 20;
+
+    if (majorVersion >= required) {
+        return {
+            pass: true,
+            message: `Node.js version: ${currentVersion} (required: >= v${required})`
+        };
+    } else {
+        return {
+            pass: false,
+            message: `Node.js version: ${currentVersion} (required: >= v${required})`,
+            suggestion: `Update Node.js to v${required} or higher`
+        };
+    }
+}
+
+/**
+ * Verifica la estructura de directorios
+ */
+async function checkDirectoryStructure() {
+    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);
+
+    if (srcExists && apiExists) {
+        return {
+            pass: true,
+            message: 'Project structure (src/ and api/) exists'
+        };
+    } else {
+        const missing = [];
+        if (!srcExists) missing.push('src/');
+        if (!apiExists) missing.push('api/');
+
+        return {
+            pass: false,
+            message: `Missing directories: ${missing.join(', ')}`,
+            suggestion: 'Run "slice init" to initialize your project'
+        };
+    }
+}
+
+/**
+ * Verifica sliceConfig.json
+ */
+async function checkConfig() {
+    const configPath = path.join(__dirname, '../../../../src/sliceConfig.json');
+
+    if (!await fs.pathExists(configPath)) {
+        return {
+            pass: false,
+            message: 'sliceConfig.json not found',
+            suggestion: 'Run "slice init" to create configuration'
+        };
+    }
+
+    try {
+        const config = await fs.readJson(configPath);
+
+        if (!config.paths || !config.paths.components) {
+            return {
+                pass: false,
+                message: 'sliceConfig.json is invalid (missing paths.components)',
+                suggestion: 'Check your configuration file'
+            };
+        }
+
+        return {
+            pass: true,
+            message: 'sliceConfig.json is valid'
+        };
+    } catch (error) {
+        return {
+            pass: false,
+            message: `sliceConfig.json is invalid JSON: ${error.message}`,
+            suggestion: 'Fix JSON syntax errors in sliceConfig.json'
+        };
+    }
+}
+
+/**
+ * Verifica disponibilidad del puerto
+ */
+async function checkPort() {
+    const configPath = path.join(__dirname, '../../../../src/sliceConfig.json');
+    let port = 3000;
+
+    try {
+        if (await fs.pathExists(configPath)) {
+            const config = await fs.readJson(configPath);
+            port = config.server?.port || 3000;
+        }
+    } catch { }
+
+    return new Promise((resolve) => {
+        const server = createServer();
+
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve({
+                    warn: true,
+                    message: `Port ${port} is already in use`,
+                    suggestion: `Stop the process using port ${port} or use: slice dev -p <other-port>`
+                });
+            } else {
+                resolve({
+                    pass: true,
+                    message: `Port ${port} is available`
+                });
+            }
+        });
+
+        server.once('listening', () => {
+            server.close();
+            resolve({
+                pass: true,
+                message: `Port ${port} is available`
+            });
+        });
+
+        server.listen(port);
+    });
+}
+
+/**
+ * Verifica dependencias en package.json
+ */
+async function checkDependencies() {
+    const packagePath = path.join(__dirname, '../../../../package.json');
+
+    if (!await fs.pathExists(packagePath)) {
+        return {
+            warn: true,
+            message: 'package.json not found',
+            suggestion: 'Run "npm init" to create package.json'
+        };
+    }
+
+    try {
+        const pkg = await fs.readJson(packagePath);
+        const hasCli = pkg.dependencies?.['slicejs-cli'] || pkg.devDependencies?.['slicejs-cli'];
+        const hasFramework = pkg.dependencies?.['slicejs-web-framework'];
+
+        if (hasCli && hasFramework) {
+            return {
+                pass: true,
+                message: 'All required dependencies are installed'
+            };
+        } else {
+            const missing = [];
+            if (!hasCli) missing.push('slicejs-cli');
+            if (!hasFramework) missing.push('slicejs-web-framework');
+
+            return {
+                warn: true,
+                message: `Missing dependencies: ${missing.join(', ')}`,
+                suggestion: 'Run "npm install"'
+            };
+        }
+    } catch (error) {
+        return {
+            pass: false,
+            message: `package.json is invalid: ${error.message}`,
+            suggestion: 'Fix JSON syntax errors in package.json'
+        };
+    }
+}
+
+/**
+ * Verifica integridad de componentes
+ */
+async function checkComponents() {
+    const configPath = path.join(__dirname, '../../../../src/sliceConfig.json');
+    const projectRoot = path.join(__dirname, '../../../../');
+
+    if (!await fs.pathExists(configPath)) {
+        return {
+            warn: true,
+            message: 'Cannot check components (no config)',
+            suggestion: 'Run "slice init" first'
+        };
+    }
+
+    try {
+        const config = await fs.readJson(configPath);
+        const componentPaths = config.paths?.components || {};
+
+        let totalComponents = 0;
+        let componentIssues = 0;
+
+        for (const [category, { path: compPath }] of Object.entries(componentPaths)) {
+            const fullPath = path.join(projectRoot, 'src', compPath);
+
+            if (await fs.pathExists(fullPath)) {
+                const items = await fs.readdir(fullPath);
+
+                for (const item of items) {
+                    const itemPath = path.join(fullPath, item);
+                    const stat = await fs.stat(itemPath);
+
+                    if (stat.isDirectory()) {
+                        totalComponents++;
+
+                        // Verificar archivos JS
+                        const jsFile = path.join(itemPath, `${item}.js`);
+                        if (!await fs.pathExists(jsFile)) {
+                            componentIssues++;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (componentIssues === 0) {
+            return {
+                pass: true,
+                message: `${totalComponents} components checked, all OK`
+            };
+        } else {
+            return {
+                warn: true,
+                message: `${componentIssues} component(s) have missing files`,
+                suggestion: 'Check your component directories'
+            };
+        }
+    } catch (error) {
+        return {
+            warn: true,
+            message: `Cannot check components: ${error.message}`,
+            suggestion: 'Verify your project structure'
+        };
+    }
+}
+
+/**
+ * Comando principal de diagnóstico
+ */
+export default async function runDiagnostics() {
+    Print.newLine();
+    Print.title('🔍 Running Slice.js Diagnostics...');
+    Print.newLine();
+
+    const checks = [
+        { name: 'Node.js Version', fn: checkNodeVersion },
+        { name: 'Project Structure', fn: checkDirectoryStructure },
+        { name: 'Configuration', fn: checkConfig },
+        { name: 'Port Availability', fn: checkPort },
+        { name: 'Dependencies', fn: checkDependencies },
+        { name: 'Components', fn: checkComponents }
+    ];
+
+    const results = [];
+
+    for (const check of checks) {
+        const result = await check.fn();
+        results.push({ ...result, name: check.name });
+    }
+
+    // Crear tabla de resultados
+    const table = new Table({
+        head: [chalk.cyan.bold('Check'), chalk.cyan.bold('Status'), chalk.cyan.bold('Details')],
+        colWidths: [25, 10, 55],
+        style: {
+            head: [],
+            border: ['gray']
+        },
+        wordWrap: true
+    });
+
+    results.forEach(result => {
+        let status;
+        if (result.pass) {
+            status = chalk.green('✅ PASS');
+        } else if (result.warn) {
+            status = chalk.yellow('⚠️  WARN');
+        } else {
+            status = chalk.red('❌ FAIL');
+        }
+
+        const details = result.suggestion
+            ? `${result.message}\n${chalk.gray('→ ' + result.suggestion)}`
+            : result.message;
+
+        table.push([result.name, status, details]);
+    });
+
+    console.log(table.toString());
+
+    // Resumen
+    const issues = results.filter(r => !r.pass && !r.warn).length;
+    const warnings = results.filter(r => r.warn).length;
+    const passed = results.filter(r => r.pass).length;
+
+    Print.newLine();
+    Print.separator();
+
+    if (issues === 0 && warnings === 0) {
+        Print.success('All checks passed! 🎉');
+        Print.info('Your Slice.js project is correctly configured');
+    } else {
+        console.log(chalk.bold('📊 Summary:'));
+        console.log(chalk.green(`  ✅ Passed: ${passed}`));
+        if (warnings > 0) console.log(chalk.yellow(`  ⚠️  Warnings: ${warnings}`));
+        if (issues > 0) console.log(chalk.red(`  ❌ Issues: ${issues}`));
+
+        Print.newLine();
+
+        if (issues > 0) {
+            Print.warning('Fix the issues above to ensure proper functionality');
+        } else {
+            Print.info('Warnings are non-critical but should be addressed');
+        }
+    }
+
+    Print.separator();
+}

package/commands/init/init.js

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import ora from 'ora';
 import Print from '../Print.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -27,40 +28,43 @@ export default async function initializeProject(projectType) {
         }
 
         // 1. COPIAR LA CARPETA API (mantener lógica original)
+        const apiSpinner = ora('Copying API structure...').start();
         try {
             if (!fs.existsSync(apiDir)) throw new Error(`No se encontró la carpeta api: ${apiDir}`);
             await fs.copy(apiDir, destinationApi, { recursive: true });
-            Print.success('Carpeta "api" copiada correctamente.');
+            apiSpinner.succeed('API structure created successfully');
         } catch (error) {
-            Print.error('Error copiando la carpeta "api":', error.message);
+            apiSpinner.fail('Error copying API structure');
+            Print.error(error.message);
             return;
         }
 
         // 2. CREAR ESTRUCTURA SRC BÁSICA (sin copiar componentes Visual)
+        const srcSpinner = ora('Creating src structure...').start();
         try {
             if (!fs.existsSync(srcDir)) throw new Error(`No se encontró la carpeta src: ${srcDir}`);
-            
+
             // Copiar solo los archivos base de src, excluyendo Components/Visual
             await fs.ensureDir(destinationSrc);
-            
+
             // Copiar archivos y carpetas de src excepto Components/Visual
             const srcItems = await fs.readdir(srcDir);
-            
+
             for (const item of srcItems) {
                 const srcItemPath = path.join(srcDir, item);
                 const destItemPath = path.join(destinationSrc, item);
                 const stat = await fs.stat(srcItemPath);
-                
+
                 if (stat.isDirectory()) {
                     if (item === 'Components') {
                         // Crear estructura de Components pero sin copiar Visual
                         await fs.ensureDir(destItemPath);
-                        
+
                         const componentItems = await fs.readdir(srcItemPath);
                         for (const componentItem of componentItems) {
                             const componentItemPath = path.join(srcItemPath, componentItem);
                             const destComponentItemPath = path.join(destItemPath, componentItem);
-                            
+
                             if (componentItem !== 'Visual') {
                                 // Copiar Service y otros tipos de components
                                 await fs.copy(componentItemPath, destComponentItemPath, { recursive: true });
@@ -78,50 +82,50 @@ export default async function initializeProject(projectType) {
                     await fs.copy(srcItemPath, destItemPath);
                 }
             }
-            
-            Print.success('Estructura "src" creada correctamente.');
+
+            srcSpinner.succeed('Source structure created successfully');
         } catch (error) {
-            Print.error('Error creando la estructura "src":', error.message);
+            srcSpinner.fail('Error creating source structure');
+            Print.error(error.message);
             return;
         }
 
         // 3. DESCARGAR TODOS LOS COMPONENTES VISUAL DESDE EL REPOSITORIO OFICIAL
+        const componentsSpinner = ora('Loading component registry...').start();
         try {
-            Print.info('Downloading all Visual components from official repository...');
-            
             const registry = new ComponentRegistry();
             await registry.loadRegistry();
-            
+
             // Obtener TODOS los componentes Visual disponibles
             const allVisualComponents = await getAllVisualComponents(registry);
-            
+
             if (allVisualComponents.length > 0) {
-                Print.info(`Installing ${allVisualComponents.length} Visual components...`);
-                
+                componentsSpinner.text = `Installing ${allVisualComponents.length} Visual components...`;
+
                 const results = await registry.installMultipleComponents(
-                    allVisualComponents, 
-                    'Visual', 
+                    allVisualComponents,
+                    'Visual',
                     true // force = true para instalación inicial
                 );
-                
+
                 const successful = results.filter(r => r.success).length;
                 const failed = results.filter(r => !r.success).length;
-                
-                if (successful > 0) {
-                    Print.success(`${successful} Visual components installed from official repository`);
-                }
-                
-                if (failed > 0) {
-                    Print.warning(`${failed} Visual components could not be installed`);
-                    Print.info('You can install them later using "slice get <component-name>"');
+
+                if (successful > 0 && failed === 0) {
+                    componentsSpinner.succeed(`All ${successful} Visual components installed successfully`);
+                } else if (successful > 0) {
+                    componentsSpinner.warn(`${successful} components installed, ${failed} failed`);
+                    Print.info('You can install failed components later using "slice get <component-name>"');
+                } else {
+                    componentsSpinner.fail('Failed to install Visual components');
                 }
             } else {
-                Print.warning('No Visual components found in registry');
+                componentsSpinner.warn('No Visual components found in registry');
                 Print.info('You can add components later using "slice get <component-name>"');
             }
-            
+
         } catch (error) {
-            Print.warning('Could not download Visual components from official repository');
+            componentsSpinner.fail('Could not download Visual components from official repository');
             Print.error(`Repository error: ${error.message}`);
             Print.info('Project initialized without Visual components');
             Print.info('You can add them later using "slice get <component-name>"');
@@ -133,7 +137,7 @@ export default async function initializeProject(projectType) {
         console.log('  slice browse          - View available components');
         console.log('  slice get Button      - Install specific components');
         console.log('  slice sync            - Update all components to latest versions');
-        
+
     } catch (error) {
         Print.error('Error inesperado al inicializar el proyecto:', error.message);
     }
@@ -147,8 +151,8 @@ export default async function initializeProject(projectType) {
 async function getAllVisualComponents(registry) {
     const availableComponents = registry.getAvailableComponents('Visual');
     const allVisualComponents = Object.keys(availableComponents);
-    
+
     Print.info(`Found ${allVisualComponents.length} Visual components in official repository`);
-    
+
     return allVisualComponents;
 }

package/commands/listComponents/listComponents.js

@@ -1,6 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import Table from 'cli-table3';
+import chalk from 'chalk';
 import Print from '../Print.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -34,7 +36,6 @@ const loadConfig = () => {
 const listComponents = (folderPath) => {
     try {
         if (!fs.existsSync(folderPath)) {
-            Print.warning(`Component directory not found: ${folderPath}`);
             return [];
         }
         const result = fs.readdirSync(folderPath);
@@ -45,6 +46,19 @@ const listComponents = (folderPath) => {
     }
 };
 
+/**
+ * Cuenta archivos en un directorio de componente
+ */
+const countComponentFiles = (componentPath) => {
+    try {
+        if (!fs.existsSync(componentPath)) return 0;
+        const files = fs.readdirSync(componentPath);
+        return files.filter(f => fs.statSync(path.join(componentPath, f)).isFile()).length;
+    } catch {
+        return 0;
+    }
+};
+
 /**
  * Obtiene los componentes dinámicamente desde sliceConfig.json
  * @returns {object} - Mapeo de componentes con su categoría
@@ -53,29 +67,27 @@ const getComponents = () => {
     const config = loadConfig();
     if (!config) return {};
 
-       //const isProduction = config.production.enabled===true;
     const folderSuffix = 'src'; // Siempre usar 'src' para desarrollo
-
-    const componentPaths = config.paths?.components || {}; // Obtiene dinámicamente las rutas de los componentes
+    const componentPaths = config.paths?.components || {};
     let allComponents = new Map();
 
     Object.entries(componentPaths).forEach(([category, { path: folderPath }]) => {
         const fullPath = path.join(__dirname, `../../../../${folderSuffix}`, folderPath);
         const files = listComponents(fullPath);
 
-
         files.forEach(file => {
-            const componentName = path.basename(file, '.js');
-            allComponents.set(componentName, category);
+            const componentPath = path.join(fullPath, file);
+            if (fs.statSync(componentPath).isDirectory()) {
+                const fileCount = countComponentFiles(componentPath);
+                allComponents.set(file, { category, files: fileCount });
+            }
         });
     });
 
-
-
     return Object.fromEntries(allComponents);
 };
 
-function listComponentsReal(){
+function listComponentsReal() {
     try {
         // Obtener componentes dinámicamente
         const components = getComponents();
@@ -86,26 +98,76 @@ function listComponentsReal(){
             return;
         }
 
+        // Crear tabla con cli-table3
+        const table = new Table({
+            head: [
+                chalk.cyan.bold('Component'),
+                chalk.cyan.bold('Category'),
+                chalk.cyan.bold('Files')
+            ],
+            colWidths: [30, 20, 10],
+            style: {
+                head: [],
+                border: ['gray']
+            }
+        });
+
+        // Agrupar por categoría para mejor visualización
+        const byCategory = {};
+        Object.entries(components).forEach(([name, data]) => {
+            if (!byCategory[data.category]) {
+                byCategory[data.category] = [];
+            }
+            byCategory[data.category].push({ name, files: data.files });
+        });
+
+        // Agregar filas a la tabla
+        Object.entries(byCategory).forEach(([category, comps]) => {
+            comps.forEach((comp, index) => {
+                if (index === 0) {
+                    // Primera fila de la categoría
+                    table.push([
+                        chalk.bold(comp.name),
+                        chalk.yellow(category),
+                        comp.files.toString()
+                    ]);
+                } else {
+                    // Resto de componentes en la categoría
+                    table.push([
+                        chalk.bold(comp.name),
+                        chalk.gray('″'),  // Ditto mark
+                        comp.files.toString()
+                    ]);
+                }
+            });
+        });
+
+        Print.newLine();
+        Print.title('📦 Local Components');
+        Print.newLine();
+        console.log(table.toString());
+        Print.newLine();
+        Print.info(`Total: ${Object.keys(components).length} component${Object.keys(components).length !== 1 ? 's' : ''} found`);
+
         // Ruta donde se generará components.js
         const outputPath = path.join(__dirname, '../../../../src/Components/components.js');
-        
+
         // Asegurar que el directorio existe
         const outputDir = path.dirname(outputPath);
         if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true });
-            Print.info('Created Components directory');
         }
 
         // Generar archivo components.js con los componentes detectados
-        fs.writeFileSync(outputPath, `const components = ${JSON.stringify(components, null, 2)};\n\nexport default components;\n`);
+        const componentsForExport = Object.fromEntries(
+            Object.entries(components).map(([name, data]) => [name, data.category])
+        );
+        fs.writeFileSync(outputPath, `const components = ${JSON.stringify(componentsForExport, null, 2)};\n\nexport default components;\n`);
 
-        Print.success(`Component list updated successfully (${Object.keys(components).length} component${Object.keys(components).length !== 1 ? 's' : ''} found)`);
     } catch (error) {
-        Print.error(`Failed to update component list: ${error.message}`);
+        Print.error(`Failed to list components: ${error.message}`);
         Print.info('Make sure your project structure is correct');
     }
 }
 
 export default listComponentsReal;
-
-