awc-zns-mtd 2.9.0 → 2.10.3

package/tools/cli/commands/validate.js

@@ -26,10 +26,10 @@ async function validateCommand() {
   checksCount++;
   if (await fs.pathExists(awcDir)) {
     passedCount++;
-    console.log(chalk.green('✓') + ' Directorio .awc existe');
+    console.log(`${chalk.green('✓')} Directorio .awc existe`);
   } else {
     errors.push('Directorio .awc no encontrado');
-    console.log(chalk.red('✗') + ' Directorio .awc no encontrado');
+    console.log(`${chalk.red('✗')} Directorio .awc no encontrado`);
   }
 
   // Check 2: Configuración
@@ -37,10 +37,10 @@ async function validateCommand() {
   const config = await loadConfig(awcDir);
   if (config) {
     passedCount++;
-    console.log(chalk.green('✓') + ' Archivo de configuración válido');
+    console.log(`${chalk.green('✓')} Archivo de configuración válido`);
   } else {
     errors.push('Archivo de configuración inválido o faltante');
-    console.log(chalk.red('✗') + ' Archivo de configuración inválido');
+    console.log(`${chalk.red('✗')} Archivo de configuración inválido`);
   }
 
   // Check 3: Agentes
@@ -48,18 +48,18 @@ async function validateCommand() {
   const agentsPath = path.join(awcDir, 'agents');
   if (await fs.pathExists(agentsPath)) {
     const agentFiles = await fs.readdir(agentsPath);
-    const yamlAgents = agentFiles.filter(f => f.endsWith('.yaml'));
+    const yamlAgents = agentFiles.filter((f) => f.endsWith('.yaml'));
 
     if (yamlAgents.length >= 4) {
       passedCount++;
-      console.log(chalk.green('✓') + ` ${yamlAgents.length} agentes encontrados`);
+      console.log(`${chalk.green('✓')} ${yamlAgents.length} agentes encontrados`);
     } else {
       warnings.push(`Solo ${yamlAgents.length} agentes encontrados (se esperan 4)`);
-      console.log(chalk.yellow('⚠') + ` Solo ${yamlAgents.length} agentes (se esperan 4)`);
+      console.log(`${chalk.yellow('⚠')} Solo ${yamlAgents.length} agentes (se esperan 4)`);
     }
   } else {
     errors.push('Directorio de agentes no encontrado');
-    console.log(chalk.red('✗') + ' Directorio de agentes no encontrado');
+    console.log(`${chalk.red('✗')} Directorio de agentes no encontrado`);
   }
 
   // Check 4: Workflows
@@ -70,14 +70,14 @@ async function validateCommand() {
 
     if (workflowDirs.length >= 3) {
       passedCount++;
-      console.log(chalk.green('✓') + ` ${workflowDirs.length} workflows encontrados`);
+      console.log(`${chalk.green('✓')} ${workflowDirs.length} workflows encontrados`);
     } else {
       warnings.push(`Solo ${workflowDirs.length} workflows encontrados (se esperan 3)`);
-      console.log(chalk.yellow('⚠') + ` Solo ${workflowDirs.length} workflows (se esperan 3)`);
+      console.log(`${chalk.yellow('⚠')} Solo ${workflowDirs.length} workflows (se esperan 3)`);
     }
   } else {
     errors.push('Directorio de workflows no encontrado');
-    console.log(chalk.red('✗') + ' Directorio de workflows no encontrado');
+    console.log(`${chalk.red('✗')} Directorio de workflows no encontrado`);
   }
 
   // Check 5: Documentación
@@ -85,7 +85,7 @@ async function validateCommand() {
   const docsPath = path.join(cwd, 'docs');
   if (await fs.pathExists(docsPath)) {
     passedCount++;
-    console.log(chalk.green('✓') + ' Directorio de documentación existe');
+    console.log(`${chalk.green('✓')} Directorio de documentación existe`);
 
     // Sub-checks de documentación
     const adrPath = path.join(docsPath, 'adr');
@@ -103,7 +103,7 @@ async function validateCommand() {
     }
   } else {
     warnings.push('Directorio de documentación no encontrado');
-    console.log(chalk.yellow('⚠') + ' Directorio de documentación no encontrado');
+    console.log(`${chalk.yellow('⚠')} Directorio de documentación no encontrado`);
   }
 
   // Resumen

package/tools/cli/commands/version.js

@@ -4,7 +4,7 @@
  */
 
 const chalk = require('chalk');
-const semver = require('semver');
+// const semver = require('semver');
 const { getVersion, checkForUpdates } = require('../utils/version');
 const { displayLogo } = require('../utils/console-logger');
 
@@ -35,7 +35,7 @@ async function versionCommand() {
     } else {
       console.log(chalk.green('\n✅ Estás usando la versión más reciente\n'));
     }
-  } catch (error) {
+  } catch {
     console.log(chalk.gray('\n  No se pudo verificar actualizaciones (sin conexión)\n'));
   }
 
@@ -43,7 +43,9 @@ async function versionCommand() {
   console.log(chalk.cyan('📚 Más información:\n'));
   console.log(`  Documentación:  ${chalk.blue('https://github.com/awc/awc-zns-mtd')}`);
   console.log(`  Issues:         ${chalk.blue('https://github.com/awc/awc-zns-mtd/issues')}`);
-  console.log(`  Changelog:      ${chalk.blue('https://github.com/awc/awc-zns-mtd/blob/main/CHANGELOG.md')}\n`);
+  console.log(
+    `  Changelog:      ${chalk.blue('https://github.com/awc/awc-zns-mtd/blob/main/CHANGELOG.md')}\n`
+  );
 }
 
 module.exports = { versionCommand };

package/tools/cli/utils/console-logger.js

@@ -11,8 +11,16 @@ const chalk = require('chalk');
 function displayLogo() {
   console.log('');
   console.log(chalk.cyan('╔═══════════════════════════════════════════════════════════╗'));
-  console.log(chalk.cyan('║') + chalk.bold.white('                  ZΞNAPSΞS by ΛNWICO                    ') + chalk.cyan('║'));
-  console.log(chalk.cyan('║') + chalk.gray('            Minimalismo Estratégico Method                 ') + chalk.cyan('║'));
+  console.log(
+    chalk.cyan('║') +
+      chalk.bold.white('                  ZΞNAPSΞS by ΛNWICO                    ') +
+      chalk.cyan('║')
+  );
+  console.log(
+    chalk.cyan('║') +
+      chalk.gray('            Minimalismo Estratégico Method                 ') +
+      chalk.cyan('║')
+  );
   console.log(chalk.cyan('╚═══════════════════════════════════════════════════════════╝'));
   console.log();
 }
@@ -21,28 +29,28 @@ function displayLogo() {
  * Muestra un mensaje de éxito
  */
 function logSuccess(message) {
-  console.log(chalk.green('✓') + ' ' + message);
+  console.log(`${chalk.green('✓')} ${message}`);
 }
 
 /**
  * Muestra un mensaje de error
  */
 function logError(message) {
-  console.log(chalk.red('✗') + ' ' + message);
+  console.log(`${chalk.red('✗')} ${message}`);
 }
 
 /**
  * Muestra un mensaje de advertencia
  */
 function logWarning(message) {
-  console.log(chalk.yellow('⚠') + ' ' + message);
+  console.log(`${chalk.yellow('⚠')} ${message}`);
 }
 
 /**
  * Muestra un mensaje informativo
  */
 function logInfo(message) {
-  console.log(chalk.blue('ℹ') + ' ' + message);
+  console.log(`${chalk.blue('ℹ')} ${message}`);
 }
 
 /**
@@ -74,9 +82,9 @@ function logProgress(current, total, message) {
  * Muestra una tabla simple
  */
 function logTable(data) {
-  const maxKeyLength = Math.max(...data.map(item => item.key.length));
+  const maxKeyLength = Math.max(...data.map((item) => item.key.length));
 
-  data.forEach(item => {
+  data.forEach((item) => {
     const paddedKey = item.key.padEnd(maxKeyLength + 2);
     console.log(`  ${chalk.gray(paddedKey)} ${chalk.yellow(item.value)}`);
   });
@@ -88,7 +96,9 @@ function logTable(data) {
 function displayWelcome(projectName) {
   console.log();
   console.log(chalk.cyan('╔═══════════════════════════════════════════════════════════╗'));
-  console.log(chalk.cyan('║') + chalk.bold.white(`  Bienvenido a ${projectName}`.padEnd(58)) + chalk.cyan('║'));
+  console.log(
+    chalk.cyan('║') + chalk.bold.white(`  Bienvenido a ${projectName}`.padEnd(58)) + chalk.cyan('║')
+  );
   console.log(chalk.cyan('╚═══════════════════════════════════════════════════════════╝'));
   console.log();
 }
@@ -99,7 +109,7 @@ function displayWelcome(projectName) {
 function displayCommands(commands) {
   console.log(chalk.cyan('\n💡 Comandos disponibles:\n'));
 
-  commands.forEach(cmd => {
+  commands.forEach((cmd) => {
     const command = chalk.green(cmd.command.padEnd(20));
     const description = chalk.gray(cmd.description);
     console.log(`  ${command} ${description}`);
@@ -113,9 +123,15 @@ function displayCommands(commands) {
  */
 function displayZnsPhilosophy() {
   console.log(chalk.cyan('\n📖 Filosofía ZNS-MTD:\n'));
-  console.log(chalk.yellow('  ZEN') + chalk.gray('         → Claridad, simplicidad deliberada, ruido mínimo'));
-  console.log(chalk.yellow('  NEUTRO') + chalk.gray('     → Objetividad, decisiones basadas en evidencia'));
-  console.log(chalk.yellow('  SISTEMÁTICO') + chalk.gray(' → Procesos repetibles, documentación rigurosa'));
+  console.log(
+    chalk.yellow('  ZEN') + chalk.gray('         → Claridad, simplicidad deliberada, ruido mínimo')
+  );
+  console.log(
+    chalk.yellow('  NEUTRO') + chalk.gray('     → Objetividad, decisiones basadas en evidencia')
+  );
+  console.log(
+    chalk.yellow('  SISTEMÁTICO') + chalk.gray(' → Procesos repetibles, documentación rigurosa')
+  );
   console.log();
 }
 
@@ -126,11 +142,19 @@ function displayCompletionBanner(success = true) {
   console.log();
   if (success) {
     console.log(chalk.green('╔═══════════════════════════════════════════════════════════╗'));
-    console.log(chalk.green('║') + chalk.bold.white('              ✅ PROCESO COMPLETADO                       ') + chalk.green('║'));
+    console.log(
+      chalk.green('║') +
+        chalk.bold.white('              ✅ PROCESO COMPLETADO                       ') +
+        chalk.green('║')
+    );
     console.log(chalk.green('╚═══════════════════════════════════════════════════════════╝'));
   } else {
     console.log(chalk.red('╔═══════════════════════════════════════════════════════════╗'));
-    console.log(chalk.red('║') + chalk.bold.white('              ❌ PROCESO FALLIDO                          ') + chalk.red('║'));
+    console.log(
+      chalk.red('║') +
+        chalk.bold.white('              ❌ PROCESO FALLIDO                          ') +
+        chalk.red('║')
+    );
     console.log(chalk.red('╚═══════════════════════════════════════════════════════════╝'));
   }
   console.log();

package/tools/cli/utils/logger.js

@@ -0,0 +1,176 @@
+/**
+ * Logger - Sistema de logging estructurado
+ * Utiliza Winston para logging centralizado
+ */
+
+const winston = require('winston');
+const path = require('path');
+const fs = require('fs-extra');
+const ConfigManager = require('../../config/config-manager');
+
+// Asegurar que existe el directorio de logs
+const logsDir = path.join(process.cwd(), ConfigManager.LOGS_DIR);
+fs.ensureDirSync(logsDir);
+
+/**
+ * Formatos personalizados
+ */
+const customFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+  winston.format.errors({ stack: true }),
+  winston.format.splat(),
+  winston.format.json()
+);
+
+const consoleFormat = winston.format.combine(
+  winston.format.colorize(),
+  winston.format.timestamp({ format: 'HH:mm:ss' }),
+  winston.format.printf(({ level, message, timestamp, ...metadata }) => {
+    let msg = `${timestamp} [${level}]: ${message}`;
+    if (Object.keys(metadata).length > 0) {
+      msg += ` ${JSON.stringify(metadata)}`;
+    }
+    return msg;
+  })
+);
+
+/**
+ * Crear logger
+ */
+const logger = winston.createLogger({
+  level: ConfigManager.DEFAULT_LOG_LEVEL,
+  format: customFormat,
+  defaultMeta: { service: 'awc-zns-mtd' },
+  transports: [
+    // Logs de error
+    new winston.transports.File({
+      filename: path.join(logsDir, 'error.log'),
+      level: 'error',
+      maxsize: 5242880, // 5MB
+      maxFiles: 5
+    }),
+
+    // Logs combinados
+    new winston.transports.File({
+      filename: path.join(logsDir, 'combined.log'),
+      maxsize: 5242880,
+      maxFiles: 5
+    }),
+
+    // Logs de comandos (solo info y superior)
+    new winston.transports.File({
+      filename: path.join(logsDir, 'commands.log'),
+      level: 'info',
+      maxsize: 5242880,
+      maxFiles: 3
+    })
+  ],
+
+  // Manejo de excepciones
+  exceptionHandlers: [
+    new winston.transports.File({
+      filename: path.join(logsDir, 'exceptions.log')
+    })
+  ],
+
+  // Manejo de rechazos de promesas
+  rejectionHandlers: [
+    new winston.transports.File({
+      filename: path.join(logsDir, 'rejections.log')
+    })
+  ]
+});
+
+// En desarrollo, también loguear a consola
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(
+    new winston.transports.Console({
+      format: consoleFormat,
+      level: 'debug'
+    })
+  );
+}
+
+/**
+ * Wrapper para comandos CLI
+ */
+class CLILogger {
+  /**
+   * Log de inicio de comando
+   * @param {string} command - Nombre del comando
+   * @param {Object} options - Opciones del comando
+   */
+  static commandStart(command, options = {}) {
+    logger.info('Command started', {
+      command,
+      options,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Log de finalización de comando
+   * @param {string} command - Nombre del comando
+   * @param {boolean} success - Si fue exitoso
+   * @param {number} duration - Duración en ms
+   */
+  static commandEnd(command, success = true, duration = 0) {
+    const level = success ? 'info' : 'error';
+    logger[level]('Command finished', {
+      command,
+      success,
+      duration: `${duration}ms`,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Log de error de comando
+   * @param {string} command - Nombre del comando
+   * @param {Error} error - Error ocurrido
+   */
+  static commandError(command, error) {
+    logger.error('Command error', {
+      command,
+      error: error.message,
+      stack: error.stack,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Log de operación de archivo
+   * @param {string} operation - Tipo de operación
+   * @param {string} filePath - Path del archivo
+   * @param {boolean} success - Si fue exitoso
+   */
+  static fileOperation(operation, filePath, success = true) {
+    logger.info('File operation', {
+      operation,
+      filePath,
+      success,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Log de validación
+   * @param {string} type - Tipo de validación
+   * @param {boolean} valid - Si es válido
+   * @param {Array<string>} errors - Errores encontrados
+   */
+  static validation(type, valid, errors = []) {
+    const level = valid ? 'info' : 'warn';
+    logger[level]('Validation', {
+      type,
+      valid,
+      errors,
+      timestamp: new Date().toISOString()
+    });
+  }
+}
+
+module.exports = {
+  logger,
+  CLILogger
+};

package/tools/cli/utils/project-analyzer.js

@@ -50,7 +50,6 @@ async function analyzeProject(projectPath) {
 
     // Calcular tamaño
     analysis.size = calculateSize(analysis);
-
   } catch (error) {
     console.error('Error en análisis:', error.message);
   }
@@ -69,16 +68,16 @@ async function detectTechnologies(projectPath) {
     'yarn.lock': ['Yarn'],
     'pnpm-lock.yaml': ['pnpm'],
     'requirements.txt': ['Python', 'pip'],
-    'Pipfile': ['Python', 'Pipenv'],
+    Pipfile: ['Python', 'Pipenv'],
     'pyproject.toml': ['Python', 'Poetry'],
-    'Gemfile': ['Ruby', 'Bundler'],
+    Gemfile: ['Ruby', 'Bundler'],
     'Cargo.toml': ['Rust', 'Cargo'],
     'go.mod': ['Go'],
     'pom.xml': ['Java', 'Maven'],
     'build.gradle': ['Java/Kotlin', 'Gradle'],
     'composer.json': ['PHP', 'Composer'],
     '.csproj': ['C#', '.NET'],
-    'Dockerfile': ['Docker'],
+    Dockerfile: ['Docker'],
     'docker-compose.yml': ['Docker Compose'],
     '.gitignore': ['Git'],
     'tsconfig.json': ['TypeScript'],
@@ -198,7 +197,7 @@ async function detectBuildTools(projectPath) {
     'rollup.config.js': 'Rollup',
     'gulpfile.js': 'Gulp',
     'Gruntfile.js': 'Grunt',
-    'Makefile': 'Make',
+    Makefile: 'Make',
     'CMakeLists.txt': 'CMake'
   };
 
@@ -220,21 +219,35 @@ function calculateComplexity(analysis) {
   let score = 0;
 
   // Basado en cantidad de archivos
-  if (fileCount > 1000) score += 3;
-  else if (fileCount > 500) score += 2;
-  else if (fileCount > 100) score += 1;
+  if (fileCount > 1000) {
+    score += 3;
+  } else if (fileCount > 500) {
+    score += 2;
+  } else if (fileCount > 100) {
+    score += 1;
+  }
 
   // Basado en cantidad de directorios
-  if (directoryCount > 100) score += 2;
-  else if (directoryCount > 50) score += 1;
+  if (directoryCount > 100) {
+    score += 2;
+  } else if (directoryCount > 50) {
+    score += 1;
+  }
 
   // Basado en cantidad de tecnologías
-  if (technologies.length > 10) score += 2;
-  else if (technologies.length > 5) score += 1;
+  if (technologies.length > 10) {
+    score += 2;
+  } else if (technologies.length > 5) {
+    score += 1;
+  }
 
   // Determinar nivel de complejidad
-  if (score >= 5) return 'high';
-  if (score >= 3) return 'medium';
+  if (score >= 5) {
+    return 'high';
+  }
+  if (score >= 3) {
+    return 'medium';
+  }
   return 'low';
 }
 
@@ -244,8 +257,12 @@ function calculateComplexity(analysis) {
 function calculateSize(analysis) {
   const { fileCount } = analysis;
 
-  if (fileCount > 1000) return 'large';
-  if (fileCount > 100) return 'medium';
+  if (fileCount > 1000) {
+    return 'large';
+  }
+  if (fileCount > 100) {
+    return 'medium';
+  }
   return 'small';
 }
 

package/tools/cli/utils/validators.js

@@ -0,0 +1,144 @@
+/**
+ * Utilidades de validación
+ * Validadores para inputs del usuario y paths del filesystem
+ */
+
+const path = require('path');
+
+/**
+ * Valida un nombre de proyecto
+ * @param {string} name - Nombre del proyecto
+ * @returns {boolean} - true si es válido
+ */
+function validateProjectName(name) {
+  if (!name || typeof name !== 'string') {
+    return false;
+  }
+
+  const trimmed = name.trim();
+
+  // Verificar que no esté vacío
+  if (trimmed.length === 0) {
+    return false;
+  }
+
+  // Solo letras, números, guiones y guiones bajos
+  const validPattern = /^[a-zA-Z0-9-_]+$/;
+  if (!validPattern.test(trimmed)) {
+    return false;
+  }
+
+  // Nombres reservados
+  const reserved = [
+    'node_modules',
+    'package.json',
+    'package-lock.json',
+    '.git',
+    '.awc',
+    'test',
+    'dist',
+    'build'
+  ];
+
+  if (reserved.includes(trimmed.toLowerCase())) {
+    return false;
+  }
+
+  // No debe contener path traversal
+  if (trimmed.includes('..') || trimmed.includes('/') || trimmed.includes('\\')) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Valida que un path sea seguro
+ * @param {string} filePath - Path a validar
+ * @returns {boolean} - true si es seguro
+ */
+function validatePath(filePath) {
+  if (!filePath || typeof filePath !== 'string') {
+    return false;
+  }
+
+  // Normalizar el path
+  const normalized = path.normalize(filePath);
+
+  // Detectar path traversal
+  if (normalized.includes('..')) {
+    return false;
+  }
+
+  // Paths del sistema prohibidos (lista básica)
+  const forbiddenPaths = [
+    '/etc',
+    '/sys',
+    '/proc',
+    'C:\\Windows',
+    'C:\\Program Files',
+    '/usr/bin',
+    '/usr/sbin'
+  ];
+
+  for (const forbidden of forbiddenPaths) {
+    if (normalized.startsWith(forbidden)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Sanitiza un path removiendo caracteres peligrosos
+ * @param {string} filePath - Path a sanitizar
+ * @returns {string} - Path sanitizado
+ */
+function sanitizePath(filePath) {
+  if (!filePath) {
+    return '';
+  }
+
+  let sanitized = filePath;
+
+  // Normalizar separadores
+  sanitized = sanitized.replace(/\\/g, '/');
+
+  // Eliminar múltiples slashes
+  sanitized = sanitized.replace(/\/+/g, '/');
+
+  // Eliminar path traversal
+  sanitized = sanitized.replace(/\.\.\//g, '');
+  sanitized = sanitized.replace(/\.\//g, '');
+
+  return path.normalize(sanitized);
+}
+
+/**
+ * Valida opciones del comando
+ * @param {Object} options - Opciones a validar
+ * @param {Array<string>} required - Campos requeridos
+ * @returns {Object} - { valid: boolean, errors: string[] }
+ */
+function validateCommandOptions(options, required = []) {
+  const errors = [];
+
+  for (const field of required) {
+    if (!options[field]) {
+      errors.push(`Campo requerido: ${field}`);
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+module.exports = {
+  validateProjectName,
+  validatePath,
+  sanitizePath,
+  validateCommandOptions
+};

package/tools/cli/utils/version.js

@@ -47,8 +47,12 @@ async function checkForUpdates(currentVersion) {
  * @returns {number} -1 si v1 < v2, 0 si v1 === v2, 1 si v1 > v2
  */
 function compareVersions(v1, v2) {
-  if (semver.lt(v1, v2)) return -1;
-  if (semver.gt(v1, v2)) return 1;
+  if (semver.lt(v1, v2)) {
+    return -1;
+  }
+  if (semver.gt(v1, v2)) {
+    return 1;
+  }
   return 0;
 }