slicejs-cli 2.2.6 → 2.2.8

package/client.js

@@ -6,7 +6,6 @@ import createComponent from "./commands/createComponent/createComponent.js";
 import listComponents from "./commands/listComponents/listComponents.js";
 import deleteComponent from "./commands/deleteComponent/deleteComponent.js";
 import getComponent, { listComponents as listRemoteComponents, syncComponents } from "./commands/getComponent/getComponent.js";
-import buildProduction, { buildCommand, serveProductionBuild } from "./commands/buildProduction/buildProduction.js";
 import startServer from "./commands/startServer/startServer.js";
 import versionChecker from "./commands/utils/versionChecker.js";
 import fs from "fs";
@@ -53,7 +52,7 @@ async function runWithVersionCheck(commandFunction, ...args) {
 
 const sliceClient = program;
 
-sliceClient.version("2.1.3").description("CLI for managing Slice.js framework components");
+sliceClient.version("2.2.6").description("CLI for managing Slice.js framework components");
 
 // INIT COMMAND
 sliceClient
@@ -75,73 +74,28 @@ sliceClient
     await versionChecker.showVersionInfo();
   });
 
-// BUILD COMMAND
+// DEV COMMAND (DEVELOPMENT) - COMANDO PRINCIPAL
 sliceClient
-  .command("build")
-  .description("Build project for production")
-  .option("--serve", "Start production server after build")
-  .option("--preview", "Start preview server after build")
-  .option("--analyze", "Analyze build without building")
-  .option("--skip-clean", "Skip cleaning previous build")
-  .option("-p, --port <port>", "Port for preview/serve server", 3001)
-  .action(async (options) => {
-    await runWithVersionCheck(async () => {
-      const success = await buildCommand({
-        serve: options.serve,
-        preview: options.preview,
-        analyze: options.analyze,
-        skipClean: options.skipClean,
-        port: parseInt(options.port)
-      });
-      
-      if (!success) {
-        process.exit(1);
-      }
-    });
-  });
-
-// START COMMAND (PRODUCTION)
-sliceClient
-  .command("start")
-  .description("Start production server (requires build first)")
-  .option("-p, --port <port>", "Port for production server", 3000)
-  .option("--build", "Build for production before starting")
+  .command("dev")
+  .description("Start development server")
+  .option("-p, --port <port>", "Port for development server", 3000)
   .action(async (options) => {
     await runWithVersionCheck(async () => {
-      const distDir = path.join(__dirname, "../../dist");
-      
-      // Verificar si existe build de producción
-      if (!fs.existsSync(distDir) && !options.build) {
-        Print.error("No production build found");
-        Print.info("Run 'slice build' first or use 'slice start --build'");
-        return false;
-      }
-      
-      // Si se solicita build, construir primero
-      if (options.build) {
-        Print.info("Building for production...");
-        const buildSuccess = await buildProduction();
-        if (!buildSuccess) {
-          Print.error("Build failed, cannot start production server");
-          return false;
-        }
-      }
-      
-      // Iniciar servidor de producción
       await startServer({
-        mode: 'production',
+        mode: 'development',
         port: parseInt(options.port)
       });
     });
   });
 
-// DEV COMMAND (DEVELOPMENT)
+// START COMMAND - ALIAS PARA DEV
 sliceClient
-  .command("dev")
-  .description("Start development server")
-  .option("-p, --port <port>", "Port for development server", 3000)
+  .command("start")
+  .description("Start development server (alias for dev)")
+  .option("-p, --port <port>", "Port for server", 3000)
   .action(async (options) => {
     await runWithVersionCheck(async () => {
+      Print.info("Starting development server...");
       await startServer({
         mode: 'development',
         port: parseInt(options.port)
@@ -358,13 +312,12 @@ sliceClient
     subcommandTerm: (cmd) => cmd.name() + ' ' + cmd.usage()
   });
 
-// Custom help - usando Print para consistencia
+// Custom help - SIMPLIFICADO para development only
 sliceClient.addHelpText('after', `
 Common Usage Examples:
   slice init                     - Initialize new Slice.js project
   slice dev                      - Start development server
-  slice build                    - Build for production
-  slice start                    - Start production server
+  slice start                    - Start development server (same as dev)
   slice get Button Card Input    - Install Visual components from registry  
   slice get FetchManager -s      - Install Service component from registry
   slice browse                   - Browse all available components
@@ -372,16 +325,18 @@ Common Usage Examples:
   slice component create         - Create new local component
 
 Command Categories:
-  • init, dev, build, start      - Project lifecycle
+  • init, dev, start             - Project lifecycle (development only)
   • get, browse, sync            - Quick registry shortcuts  
   • component <cmd>              - Local component management
   • registry <cmd>               - Official repository operations
   • version, update              - Maintenance commands
 
-Development vs Production:
-  • slice dev    - Development server (serves from /src)
-  • slice build  - Create optimized /dist build  
-  • slice start  - Production server (serves from /dist)
+Development Workflow:
+  • slice init    - Initialize project
+  • slice dev     - Start development server (serves from /src)
+  • slice start   - Alternative to dev command
+
+Note: Production builds are disabled. Use development mode for all workflows.
 
 More info: https://slice-js-docs.vercel.app/
 `);
@@ -402,10 +357,9 @@ program.on('command:*', () => {
   process.exit(1);
 });
 
-//CREATE HELP Command
+// HELP Command
 const helpCommand = sliceClient.command("help").description("Display help information for Slice.js CLI").action(() => {
   sliceClient.outputHelp();
-}
-);
+});
 
 program.parse();

package/commands/buildProduction/buildProduction.js

@@ -1,9 +1,9 @@
-// commands/buildProduction/buildProduction.js - CON SLICECONFIG PORT
+// commands/buildProduction/buildProduction.js - VERSIÓN LIMPIA
 
 import fs from 'fs-extra';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import UglifyJS from 'uglify-js';
+import { minify as terserMinify } from 'terser';
 import { minify } from 'html-minifier-terser';
 import CleanCSS from 'clean-css';
 import Print from '../Print.js';
@@ -36,7 +36,67 @@ async function checkBuildDependencies() {
     return false;
   }
   
-  return true;
+  try {
+    await import('terser');
+    await import('clean-css');
+    await import('html-minifier-terser');
+    Print.success('Build dependencies available');
+    return true;
+  } catch (error) {
+    Print.warning('Some build dependencies missing - using fallback copy mode');
+    return true;
+  }
+}
+
+/**
+ * Verifica que existan los archivos críticos para Slice.js
+ */
+async function verifySliceFiles(srcDir) {
+  Print.info('Verifying Slice.js critical files...');
+  
+  const criticalFiles = [
+    'sliceConfig.json',
+    'Components/components.js',
+    'App/index.js'
+  ];
+  
+  for (const file of criticalFiles) {
+    const filePath = path.join(srcDir, file);
+    if (!await fs.pathExists(filePath)) {
+      throw new Error(`Critical Slice.js file missing: ${file}`);
+    }
+  }
+  
+  Print.success('All critical Slice.js files verified');
+}
+
+/**
+ * Verifica la integridad del build para Slice.js
+ */
+async function verifyBuildIntegrity(distDir) {
+  Print.info('Verifying build integrity for Slice.js...');
+  
+  const criticalBuiltFiles = [
+    'sliceConfig.json',
+    'Components/components.js',
+    'App/index.js'
+  ];
+  
+  for (const file of criticalBuiltFiles) {
+    const filePath = path.join(distDir, file);
+    if (!await fs.pathExists(filePath)) {
+      throw new Error(`Critical built file missing: ${file}`);
+    }
+    
+    if (file === 'Components/components.js') {
+      const content = await fs.readFile(filePath, 'utf8');
+      if (!content.includes('const components') || !content.includes('export default')) {
+        throw new Error('components.js structure corrupted during build');
+      }
+    }
+  }
+  
+  Print.success('Build integrity verified - all Slice.js components preserved');
 }
 
 /**
@@ -77,48 +137,130 @@ async function processDirectory(srcPath, distPath, baseSrcPath) {
  */
 async function processFile(srcFilePath, distFilePath) {
   const ext = path.extname(srcFilePath).toLowerCase();
+  const fileName = path.basename(srcFilePath);
   
   try {
-    if (ext === '.js') {
+    if (fileName === 'components.js') {
+      await processComponentsFile(srcFilePath, distFilePath);
+    } else if (ext === '.js') {
       await minifyJavaScript(srcFilePath, distFilePath);
     } else if (ext === '.css') {
       await minifyCSS(srcFilePath, distFilePath);
     } else if (ext === '.html') {
       await minifyHTML(srcFilePath, distFilePath);
+    } else if (fileName === 'sliceConfig.json') {
+      await fs.copy(srcFilePath, distFilePath);
+      Print.info(`📄 Preserved: ${fileName} (configuration file)`);
     } else {
-      // Copiar archivos que no necesitan minificación
       await fs.copy(srcFilePath, distFilePath);
+      const stat = await fs.stat(srcFilePath);
+      const sizeKB = (stat.size / 1024).toFixed(1);
+      Print.info(`📄 Copied: ${fileName} (${sizeKB} KB)`);
     }
   } catch (error) {
-    Print.error(`Processing ${path.basename(srcFilePath)}: ${error.message}`);
-    // Copiar archivo original si falla la minificación
+    Print.error(`Processing ${fileName}: ${error.message}`);
     await fs.copy(srcFilePath, distFilePath);
   }
 }
 
 /**
- * Minifica archivos JavaScript
+ * Procesa el archivo components.js de forma especial
+ */
+async function processComponentsFile(srcPath, distPath) {
+  const content = await fs.readFile(srcPath, 'utf8');
+  const originalSize = Buffer.byteLength(content, 'utf8');
+  
+  const result = await terserMinify(content, {
+    compress: false,
+    mangle: false,
+    format: {
+      comments: false,
+      beautify: false,
+      indent_level: 0
+    }
+  });
+
+  if (result.error) {
+    throw new Error(`Terser error in components.js: ${result.error}`);
+  }
+
+  await fs.writeFile(distPath, result.code, 'utf8');
+  
+  const minifiedSize = Buffer.byteLength(result.code, 'utf8');
+  const savings = Math.round(((originalSize - minifiedSize) / originalSize) * 100);
+  
+  Print.minificationResult(`${path.basename(srcPath)} (preserved structure)`, originalSize, minifiedSize, savings);
+}
+
+/**
+ * Minifica archivos JavaScript preservando la arquitectura de Slice.js
  */
 async function minifyJavaScript(srcPath, distPath) {
   const content = await fs.readFile(srcPath, 'utf8');
   const originalSize = Buffer.byteLength(content, 'utf8');
   
-  const result = UglifyJS.minify(content, {
+  const result = await terserMinify(content, {
     compress: {
       drop_console: false,
       drop_debugger: true,
-      pure_funcs: ['console.log']
+      pure_funcs: [],
+      passes: 1,
+      unused: false,
+      side_effects: false,
+      reduce_vars: false,
+      collapse_vars: false
     },
     mangle: {
-      reserved: ['slice', 'Slice']
+      reserved: [
+        // Core Slice
+        'slice', 'Slice', 'SliceJS', 'window', 'document',
+        // Clases principales
+        'Controller', 'StylesManager', 'Router', 'Logger', 'Debugger',
+        // Métodos de Slice
+        'getClass', 'isProduction', 'getComponent', 'build', 'setTheme', 'attachTemplate',
+        // Controller
+        'componentCategories', 'templates', 'classes', 'requestedStyles', 'activeComponents',
+        'registerComponent', 'registerComponentsRecursively', 'loadTemplateToComponent',
+        'fetchText', 'setComponentProps', 'verifyComponentIds', 'destroyComponent',
+        // StylesManager
+        'componentStyles', 'themeManager', 'init', 'appendComponentStyles', 'registerComponentStyles',
+        // Router
+        'routes', 'pathToRouteMap', 'activeRoute', 'navigate', 'matchRoute', 'handleRoute',
+        'onRouteChange', 'loadInitialRoute', 'renderRoutesComponentsInPage',
+        // Propiedades de componentes
+        'sliceId', 'sliceType', 'sliceConfig', 'debuggerProps', 'parentComponent',
+        'value', 'customColor', 'icon', 'layout', 'view', 'items', 'columns', 'rows',
+        'onClickCallback', 'props',
+        // Custom Elements
+        'customElements', 'define', 'HTMLElement',
+        // DOM APIs críticas
+        'addEventListener', 'removeEventListener', 'querySelector', 'querySelectorAll',
+        'appendChild', 'removeChild', 'innerHTML', 'textContent', 'style', 'classList',
+        // Lifecycle
+        'beforeMount', 'afterMount', 'beforeDestroy', 'afterDestroy',
+        'mount', 'unmount', 'destroy', 'update', 'start', 'stop',
+        // Browser APIs
+        'fetch', 'setTimeout', 'clearTimeout', 'localStorage', 'history', 'pushState',
+        // Exports/Imports
+        'default', 'export', 'import', 'from', 'await', 'async',
+        // Nombres de componentes
+        'Button', 'Grid', 'Layout', 'HomePage', 'NotFound', 'Loading', 'TreeView', 'Link',
+        'FetchManager', 'Translator'
+      ],
+      properties: {
+        regex: /^(slice|_|\$|on[A-Z]|get|set|has|is)/
+      }
     },
-    output: {
-      comments: false
-    }
+    format: {
+      comments: false,
+      beautify: false
+    },
+    keep_fnames: true,
+    keep_classnames: true
   });
 
   if (result.error) {
-    throw new Error(`UglifyJS error: ${result.error}`);
+    throw new Error(`Terser error: ${result.error}`);
   }
 
   await fs.writeFile(distPath, result.code, 'utf8');
@@ -170,7 +312,14 @@ async function minifyHTML(srcPath, distPath) {
     removeStyleLinkTypeAttributes: true,
     useShortDoctype: true,
     minifyCSS: true,
-    minifyJS: true
+    minifyJS: {
+      mangle: {
+        reserved: ['slice', 'Slice', 'SliceJS', 'sliceId', 'sliceConfig']
+      }
+    },
+    ignoreCustomFragments: [
+      /slice-[\w-]+="[^"]*"/g
+    ]
   });
 
   await fs.writeFile(distPath, minified, 'utf8');
@@ -255,7 +404,7 @@ async function analyzeBuild() {
 }
 
 /**
- * Función principal de build
+ * FUNCIÓN PRINCIPAL DE BUILD
  */
 export default async function buildProduction(options = {}) {
   const startTime = Date.now();
@@ -267,12 +416,13 @@ export default async function buildProduction(options = {}) {
     const srcDir = path.join(__dirname, '../../../../src');
     const distDir = path.join(__dirname, '../../../../dist');
     
-    // Verificar que existe el directorio src
     if (!await fs.pathExists(srcDir)) {
       throw new Error('Source directory not found. Run "slice init" first.');
     }
 
-    // 1. Limpiar directorio dist
+    await verifySliceFiles(srcDir);
+
+    // Limpiar directorio dist
     if (await fs.pathExists(distDir)) {
       if (!options.skipClean) {
         Print.info('Cleaning previous build...');
@@ -282,32 +432,26 @@ export default async function buildProduction(options = {}) {
     }
     
     await fs.ensureDir(distDir);
-
-    // 2. Copiar sliceConfig.json sin modificaciones
     await copySliceConfig();
 
-    // 3. Procesar todos los archivos de src
-    Print.info('Processing and minifying source files...');
+    // Procesar archivos
+    Print.info('Processing and optimizing source files for Slice.js...');
     await processDirectory(srcDir, distDir, srcDir);
     Print.success('All source files processed and optimized');
 
-    // 4. Crear bundle optimizado del archivo principal
+    await verifyBuildIntegrity(distDir);
     await createOptimizedBundle();
-
-    // 5. Generar estadísticas
     await generateBuildStats(srcDir, distDir);
 
-    // 6. Tiempo total
     const buildTime = ((Date.now() - startTime) / 1000).toFixed(1);
     
     Print.newLine();
-    Print.success(`✨ Production build completed in ${buildTime}s`);
+    Print.success(`✨ Slice.js production build completed in ${buildTime}s`);
     Print.info('Your optimized project is ready in the /dist directory');
     Print.newLine();
     Print.info('Next steps:');
     console.log('  • Use "npm run slice:start" to test the production build');
-    console.log('  • Deploy both /api and /dist directories to your hosting provider');
-    console.log('  • Use "slice build --serve" to preview the production build');
+    console.log('  • All Slice.js components and architecture preserved');
     
     return true;
 
@@ -334,19 +478,15 @@ export async function serveProductionBuild(port) {
 
     Print.info(`Starting production preview server on port ${finalPort}...`);
     
-    // Implementar servidor estático simple
     const express = await import('express');
     const app = express.default();
     
-    // Servir archivos estáticos desde dist
     app.use(express.default.static(distDir));
     
-    // SPA fallback - servir index.html para rutas no encontradas
     app.get('*', (req, res) => {
       const indexPath = path.join(distDir, 'App/index.html');
       const fallbackPath = path.join(distDir, 'index.html');
       
-      // Intentar primero App/index.html, luego index.html
       if (fs.existsSync(indexPath)) {
         res.sendFile(indexPath);
       } else if (fs.existsSync(fallbackPath)) {
@@ -376,24 +516,20 @@ export async function buildCommand(options = {}) {
   const config = loadConfig();
   const defaultPort = config?.server?.port || 3001;
   
-  // Verificar dependencias necesarias
   if (!await checkBuildDependencies()) {
     return false;
   }
 
   if (options.serve) {
-    // Solo servir build existente
     await serveProductionBuild(options.port || defaultPort);
     return true;
   }
 
   if (options.analyze) {
-    // Analizar build sin construir
     await analyzeBuild();
     return true;
   }
 
-  // Build completo
   const success = await buildProduction(options);
   
   if (success && options.preview) {

package/commands/listComponents/listComponents.js

@@ -43,8 +43,8 @@ const getComponents = () => {
     const config = loadConfig();
     if (!config) return {};
 
-    const isProduction = config.production.enabled===true;
-    const folderSuffix = isProduction ? 'dist' : 'src';
+       //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
     let allComponents = new Map();

package/package.json

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

package/post.js

@@ -22,11 +22,10 @@ fs.promises.access(projectPackageJsonPath, fs.constants.F_OK)
         // Add custom commands to the project scripts
         projectPackageJson.scripts = projectPackageJson.scripts || {};
         
-        // Main project commands
+        // Main project commands - SOLO DEVELOPMENT
         projectPackageJson.scripts['slice:init'] = 'node node_modules/slicejs-cli/client.js init';
         projectPackageJson.scripts['slice:dev'] = 'node api/index.js --development';
-        projectPackageJson.scripts['slice:start'] = 'node api/index.js --production';
-        projectPackageJson.scripts['slice:build'] = 'node node_modules/slicejs-cli/client.js build';
+        projectPackageJson.scripts['slice:start'] = 'node api/index.js --development';
         projectPackageJson.scripts['slice:version'] = 'node node_modules/slicejs-cli/client.js version';
         projectPackageJson.scripts['slice:update'] = 'node node_modules/slicejs-cli/client.js update';
         
@@ -45,12 +44,7 @@ fs.promises.access(projectPackageJsonPath, fs.constants.F_OK)
         projectPackageJson.scripts['slice:registry-list'] = 'node node_modules/slicejs-cli/client.js registry list';
         projectPackageJson.scripts['slice:registry-sync'] = 'node node_modules/slicejs-cli/client.js registry sync';
         
-        // Build-related commands
-        projectPackageJson.scripts['slice:build-serve'] = 'node node_modules/slicejs-cli/client.js build --serve';
-        projectPackageJson.scripts['slice:build-preview'] = 'node node_modules/slicejs-cli/client.js build --preview';
-        projectPackageJson.scripts['slice:build-analyze'] = 'node node_modules/slicejs-cli/client.js build --analyze';
-        
-        // Legacy/compatibility commands - ACTUALIZADOS
+        // Legacy commands - SOLO DEVELOPMENT
         projectPackageJson.scripts['run'] = 'node api/index.js --development';
         projectPackageJson.scripts['development'] = 'node api/index.js --development';
 
@@ -68,8 +62,7 @@ fs.promises.access(projectPackageJsonPath, fs.constants.F_OK)
         console.log('\n🚀 Main workflow commands:');
         console.log('  npm run slice:init         - Initialize Slice.js project');
         console.log('  npm run slice:dev          - Start development server (serves from /src)');
-        console.log('  npm run slice:build        - Build for production (creates /dist)');
-        console.log('  npm run slice:start        - Start production server (serves from /dist)');
+        console.log('  npm run slice:start        - Start development server (same as dev)');
         console.log('\n📦 Component management:');
         console.log('  npm run slice:get Button   - Get components from official repository');
         console.log('  npm run slice:browse       - View all available components');
@@ -78,23 +71,14 @@ fs.promises.access(projectPackageJsonPath, fs.constants.F_OK)
         console.log('  npm run slice:create       - Create local component');
         console.log('  npm run slice:list         - List local components');
         console.log('  npm run slice:delete       - Delete local component');
-        console.log('\n🔧 Build utilities:');
-        console.log('  npm run slice:build-serve  - Build and serve immediately');
-        console.log('  npm run slice:build-preview- Build and preview');
-        console.log('  npm run slice:build-analyze- Analyze build size');
         console.log('\n🔧 Other utilities:');
         console.log('  npm run slice:version      - View version information');
         console.log('  npm run slice:update       - Check for available updates');
-        console.log('\n🎯 Development workflow:');
+        console.log('\n🎯 Simplified workflow:');
         console.log('  1. npm run slice:init      - Initialize project');
-        console.log('  2. npm run slice:dev       - Develop with hot reload');
-        console.log('  3. npm run slice:build     - Build for production');
-        console.log('  4. npm run slice:start     - Test production build');
-        console.log('\n💡 Tip: Use "slice:sync" to keep your components updated');
-        console.log('\n🔧 New argument-based system:');
-        console.log('  • slice:dev   → node api/index.js --development');
-        console.log('  • slice:start → node api/index.js --production');
-        console.log('  • Arguments take precedence over environment variables');
+        console.log('  2. npm run slice:dev       - Start development server');
+        console.log('  3. Develop and iterate     - No build step needed!');
+        console.log('\n💡 Development-focused: All commands serve from /src for instant changes');
     })
     .catch(err => {
         if (err.code === 'ENOENT') {
@@ -105,11 +89,10 @@ fs.promises.access(projectPackageJsonPath, fs.constants.F_OK)
                 description: 'Slice.js project',
                 main: 'api/index.js',
                 scripts: {
-                    // Main workflow commands - UPDATED with arguments
+                    // Main workflow commands - SOLO DEVELOPMENT
                     'slice:init': 'node node_modules/slicejs-cli/client.js init',
                     'slice:dev': 'node api/index.js --development',
-                    'slice:start': 'node api/index.js --production',
-                    'slice:build': 'node node_modules/slicejs-cli/client.js build',
+                    'slice:start': 'node api/index.js --development',
                     'slice:version': 'node node_modules/slicejs-cli/client.js version',
                     'slice:update': 'node node_modules/slicejs-cli/client.js update',
                     
@@ -123,12 +106,7 @@ fs.promises.access(projectPackageJsonPath, fs.constants.F_OK)
                     'slice:browse': 'node node_modules/slicejs-cli/client.js browse',
                     'slice:sync': 'node node_modules/slicejs-cli/client.js sync',
                     
-                    // Build utilities
-                    'slice:build-serve': 'node node_modules/slicejs-cli/client.js build --serve',
-                    'slice:build-preview': 'node node_modules/slicejs-cli/client.js build --preview',
-                    'slice:build-analyze': 'node node_modules/slicejs-cli/client.js build --analyze',
-                    
-                    // Legacy commands - UPDATED
+                    // Legacy commands - SOLO DEVELOPMENT
                     'run': 'node api/index.js --development',
                     'development': 'node api/index.js --development'
                 },
@@ -145,16 +123,16 @@ fs.promises.access(projectPackageJsonPath, fs.constants.F_OK)
     })
     .then(() => {
         console.log('✅ SliceJS CLI commands configured successfully');
-        console.log('\n🎯 Updated workflow:');
+        console.log('\n🎯 Simplified development workflow:');
         console.log('  npm run slice:dev    → node api/index.js --development (serves /src)');
-        console.log('  npm run slice:start  → node api/index.js --production (serves /dist)');
+        console.log('  npm run slice:start  → node api/index.js --development (same as dev)');
         console.log('\n🔧 Benefits:');
-        console.log('  • Clear argument-based mode detection');
-        console.log('  • No confusion between src/dist directories');
-        console.log('  • Maintains backward compatibility with NODE_ENV');
-        console.log('  • More reliable and predictable behavior');
+        console.log('  • Simple development-only workflow');
+        console.log('  • Instant changes without build steps');
+        console.log('  • Always serves from /src directory');
+        console.log('  • Interactive menu always available');
     })
     .catch(err => {
         console.error('❌ Error setting up package.json:', err.message);
         process.exit(1);
-    });
+    });