awc-zns-mtd 2.0.0

package/tools/cli/commands/status.js

@@ -0,0 +1,128 @@
+/**
+ * Comando: status
+ * Muestra el estado actual del proyecto ZNS-MTD
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { loadConfig } = require('../utils/file-utils');
+const { displayLogo } = require('../utils/console-logger');
+
+async function statusCommand(options = {}) {
+  const cwd = process.cwd();
+  const awcDir = path.join(cwd, '.awc');
+  const verbose = options.verbose || false;
+
+  displayLogo();
+
+  console.log(chalk.cyan('\n📊 Estado del Proyecto AWC ZNS-MTD\n'));
+
+  // Verificar si está instalado
+  if (!(await fs.pathExists(awcDir))) {
+    console.log(chalk.red('❌ AWC ZNS-MTD no está instalado en este proyecto.'));
+    console.log(chalk.yellow(`\n💡 Ejecuta ${chalk.green('awc install')} para comenzar.\n`));
+    return;
+  }
+
+  // Cargar configuración
+  const config = await loadConfig(awcDir);
+
+  if (!config) {
+    console.log(chalk.red('❌ Error al cargar configuración.'));
+    return;
+  }
+
+  // Información básica
+  console.log(chalk.cyan('🔧 Configuración:'));
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(`  Versión instalada:     ${chalk.yellow(config.version || 'N/A')}`);
+  console.log(`  Instalado el:          ${chalk.yellow(config.installedAt ? new Date(config.installedAt).toLocaleString('es-ES') : 'N/A')}`);
+  console.log(`  Tipo de proyecto:      ${chalk.yellow(config.projectType || 'N/A')}`);
+  console.log(`  Tamaño de equipo:      ${chalk.yellow(config.teamSize || 'N/A')}`);
+  console.log(`  Nivel técnico:         ${chalk.yellow(config.skillLevel || 'N/A')}`);
+  console.log(chalk.gray('─'.repeat(60)));
+
+  // Verificar estructura
+  console.log(chalk.cyan('\n📁 Estructura:'));
+  console.log(chalk.gray('─'.repeat(60)));
+
+  const agentsPath = path.join(awcDir, 'agents');
+  const workflowsPath = path.join(awcDir, 'workflows');
+  const docsPath = path.join(cwd, 'docs');
+
+  const agentsExist = await fs.pathExists(agentsPath);
+  const workflowsExist = await fs.pathExists(workflowsPath);
+  const docsExist = await fs.pathExists(docsPath);
+
+  console.log(`  Agentes:    ${agentsExist ? chalk.green('✓') : chalk.red('✗')} ${agentsPath}`);
+  console.log(`  Workflows:  ${workflowsExist ? chalk.green('✓') : chalk.red('✗')} ${workflowsPath}`);
+  console.log(`  Docs:       ${docsExist ? chalk.green('✓') : chalk.red('✗')} ${docsPath}`);
+
+  if (verbose) {
+    // Contar agentes
+    if (agentsExist) {
+      const agentFiles = await fs.readdir(agentsPath);
+      const yamlAgents = agentFiles.filter(f => f.endsWith('.yaml'));
+      console.log(chalk.gray(`    → ${yamlAgents.length} agentes disponibles`));
+    }
+
+    // Contar workflows
+    if (workflowsExist) {
+      const workflowDirs = await fs.readdir(workflowsPath);
+      console.log(chalk.gray(`    → ${workflowDirs.length} workflows disponibles`));
+    }
+  }
+
+  console.log(chalk.gray('─'.repeat(60)));
+
+  // Análisis de documentación
+  if (docsExist) {
+    console.log(chalk.cyan('\n📝 Documentación:'));
+    console.log(chalk.gray('─'.repeat(60)));
+
+    const adrPath = path.join(docsPath, 'adr');
+    const storiesPath = path.join(docsPath, 'stories');
+    const archPath = path.join(docsPath, 'architecture');
+
+    if (await fs.pathExists(adrPath)) {
+      const adrFiles = await fs.readdir(adrPath);
+      console.log(`  ADRs:           ${chalk.yellow(adrFiles.length)} documentos`);
+    }
+
+    if (await fs.pathExists(storiesPath)) {
+      const storyFiles = await fs.readdir(storiesPath);
+      console.log(`  User Stories:   ${chalk.yellow(storyFiles.length)} historias`);
+    }
+
+    if (await fs.pathExists(archPath)) {
+      const archFiles = await fs.readdir(archPath);
+      console.log(`  Arquitectura:   ${chalk.yellow(archFiles.length)} documentos`);
+    }
+
+    console.log(chalk.gray('─'.repeat(60)));
+  }
+
+  // Estado general
+  const allGood = agentsExist && workflowsExist && docsExist;
+
+  console.log(chalk.cyan('\n✨ Estado General:'));
+  console.log(chalk.gray('─'.repeat(60)));
+
+  if (allGood) {
+    console.log(chalk.green('  ✅ Sistema AWC ZNS-MTD funcionando correctamente'));
+  } else {
+    console.log(chalk.yellow('  ⚠️  Algunos componentes están faltando'));
+    console.log(chalk.gray(`     Ejecuta ${chalk.green('awc install --force')} para reparar`));
+  }
+
+  console.log(chalk.gray('─'.repeat(60)));
+
+  // Comandos sugeridos
+  console.log(chalk.cyan('\n💡 Comandos útiles:\n'));
+  console.log(`  ${chalk.green('awc init')}       - Analizar proyecto y recomendar workflow`);
+  console.log(`  ${chalk.green('awc config')}     - Configurar preferencias`);
+  console.log(`  ${chalk.green('awc validate')}   - Validar estructura del proyecto\n`);
+}
+
+module.exports = { statusCommand };

package/tools/cli/commands/validate.js

@@ -0,0 +1,147 @@
+/**
+ * Comando: validate
+ * Valida la estructura y configuración del proyecto ZNS-MTD
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { loadConfig } = require('../utils/file-utils');
+const { displayLogo } = require('../utils/console-logger');
+
+async function validateCommand() {
+  const cwd = process.cwd();
+  const awcDir = path.join(cwd, '.awc');
+
+  displayLogo();
+
+  console.log(chalk.cyan('\n🔍 Validación del Proyecto ZNS-MTD\n'));
+
+  const errors = [];
+  const warnings = [];
+  let checksCount = 0;
+  let passedCount = 0;
+
+  // Check 1: Instalación
+  checksCount++;
+  if (await fs.pathExists(awcDir)) {
+    passedCount++;
+    console.log(chalk.green('✓') + ' Directorio .awc existe');
+  } else {
+    errors.push('Directorio .awc no encontrado');
+    console.log(chalk.red('✗') + ' Directorio .awc no encontrado');
+  }
+
+  // Check 2: Configuración
+  checksCount++;
+  const config = await loadConfig(awcDir);
+  if (config) {
+    passedCount++;
+    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');
+  }
+
+  // Check 3: Agentes
+  checksCount++;
+  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'));
+
+    if (yamlAgents.length >= 4) {
+      passedCount++;
+      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)`);
+    }
+  } else {
+    errors.push('Directorio de agentes no encontrado');
+    console.log(chalk.red('✗') + ' Directorio de agentes no encontrado');
+  }
+
+  // Check 4: Workflows
+  checksCount++;
+  const workflowsPath = path.join(awcDir, 'workflows');
+  if (await fs.pathExists(workflowsPath)) {
+    const workflowDirs = await fs.readdir(workflowsPath);
+
+    if (workflowDirs.length >= 3) {
+      passedCount++;
+      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)`);
+    }
+  } else {
+    errors.push('Directorio de workflows no encontrado');
+    console.log(chalk.red('✗') + ' Directorio de workflows no encontrado');
+  }
+
+  // Check 5: Documentación
+  checksCount++;
+  const docsPath = path.join(cwd, 'docs');
+  if (await fs.pathExists(docsPath)) {
+    passedCount++;
+    console.log(chalk.green('✓') + ' Directorio de documentación existe');
+
+    // Sub-checks de documentación
+    const adrPath = path.join(docsPath, 'adr');
+    const storiesPath = path.join(docsPath, 'stories');
+    const archPath = path.join(docsPath, 'architecture');
+
+    if (!(await fs.pathExists(adrPath))) {
+      warnings.push('Directorio de ADRs no encontrado');
+    }
+    if (!(await fs.pathExists(storiesPath))) {
+      warnings.push('Directorio de stories no encontrado');
+    }
+    if (!(await fs.pathExists(archPath))) {
+      warnings.push('Directorio de architecture no encontrado');
+    }
+  } else {
+    warnings.push('Directorio de documentación no encontrado');
+    console.log(chalk.yellow('⚠') + ' Directorio de documentación no encontrado');
+  }
+
+  // Resumen
+  console.log(chalk.cyan('\n📊 Resumen de Validación:\n'));
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(`  Total de checks:    ${chalk.yellow(checksCount)}`);
+  console.log(`  Pasados:            ${chalk.green(passedCount)}`);
+  console.log(`  Errores:            ${chalk.red(errors.length)}`);
+  console.log(`  Advertencias:       ${chalk.yellow(warnings.length)}`);
+  console.log(chalk.gray('─'.repeat(60)));
+
+  // Errores
+  if (errors.length > 0) {
+    console.log(chalk.red('\n❌ Errores Encontrados:\n'));
+    errors.forEach((error, index) => {
+      console.log(`  ${index + 1}. ${error}`);
+    });
+  }
+
+  // Advertencias
+  if (warnings.length > 0) {
+    console.log(chalk.yellow('\n⚠️  Advertencias:\n'));
+    warnings.forEach((warning, index) => {
+      console.log(`  ${index + 1}. ${warning}`);
+    });
+  }
+
+  // Resultado final
+  console.log();
+  if (errors.length === 0 && warnings.length === 0) {
+    console.log(chalk.green('✅ ¡Proyecto AWC ZNS-MTD totalmente válido!\n'));
+  } else if (errors.length === 0) {
+    console.log(chalk.yellow('⚠️  Proyecto válido con algunas advertencias\n'));
+    console.log(chalk.gray(`   Ejecuta ${chalk.green('awc install --force')} para reparar\n`));
+  } else {
+    console.log(chalk.red('❌ Proyecto tiene errores que requieren atención\n'));
+    console.log(chalk.gray(`   Ejecuta ${chalk.green('awc install --force')} para reparar\n`));
+  }
+}
+
+module.exports = { validateCommand };

package/tools/cli/commands/version.js

@@ -0,0 +1,49 @@
+/**
+ * Comando: version
+ * Verifica la versión instalada y actualizaciones disponibles
+ */
+
+const chalk = require('chalk');
+const semver = require('semver');
+const { getVersion, checkForUpdates } = require('../utils/version');
+const { displayLogo } = require('../utils/console-logger');
+
+async function versionCommand() {
+  displayLogo();
+
+  console.log(chalk.cyan('\n🔍 Información de Versión\n'));
+
+  const currentVersion = getVersion();
+
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(`  Versión actual:     ${chalk.yellow(currentVersion)}`);
+  console.log(`  Método:             ${chalk.cyan('AWC ZNS-MTD')}`);
+  console.log(`  Inspirado en:       ${chalk.gray('BMAD Core V6')}`);
+  console.log(chalk.gray('─'.repeat(60)));
+
+  // Verificar actualizaciones
+  console.log(chalk.cyan('\n🔄 Verificando actualizaciones...'));
+
+  try {
+    const updateInfo = await checkForUpdates(currentVersion);
+
+    if (updateInfo.hasUpdate) {
+      console.log(chalk.yellow('\n⚠️  Nueva versión disponible!\n'));
+      console.log(`  Actual:      ${chalk.red(currentVersion)}`);
+      console.log(`  Disponible:  ${chalk.green(updateInfo.latestVersion)}`);
+      console.log(`\n💡 Actualiza con: ${chalk.green('npm install -g awc-zns-mtd@latest')}\n`);
+    } else {
+      console.log(chalk.green('\n✅ Estás usando la versión más reciente\n'));
+    }
+  } catch (error) {
+    console.log(chalk.gray('\n  No se pudo verificar actualizaciones (sin conexión)\n'));
+  }
+
+  // Información adicional
+  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`);
+}
+
+module.exports = { versionCommand };

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

@@ -0,0 +1,153 @@
+/**
+ * Console Logger
+ * Utilidades para mostrar mensajes formateados en consola
+ */
+
+const chalk = require('chalk');
+
+/**
+ * Muestra el logo de AWC ZNS-MTD
+ */
+function displayLogo() {
+  console.log();
+  console.log(chalk.cyan('╔═══════════════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('║') + chalk.bold.white('                    AWC ZNS-MTD                           ') + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.gray('          Zen · Neutro · Sistemático Method                ') + chalk.cyan('║'));
+  console.log(chalk.cyan('╚═══════════════════════════════════════════════════════════╝'));
+  console.log();
+}
+
+/**
+ * Muestra un mensaje de éxito
+ */
+function logSuccess(message) {
+  console.log(chalk.green('✓') + ' ' + message);
+}
+
+/**
+ * Muestra un mensaje de error
+ */
+function logError(message) {
+  console.log(chalk.red('✗') + ' ' + message);
+}
+
+/**
+ * Muestra un mensaje de advertencia
+ */
+function logWarning(message) {
+  console.log(chalk.yellow('⚠') + ' ' + message);
+}
+
+/**
+ * Muestra un mensaje informativo
+ */
+function logInfo(message) {
+  console.log(chalk.blue('ℹ') + ' ' + message);
+}
+
+/**
+ * Muestra un separador
+ */
+function logSeparator(length = 60) {
+  console.log(chalk.gray('─'.repeat(length)));
+}
+
+/**
+ * Muestra un título de sección
+ */
+function logSection(title) {
+  console.log();
+  console.log(chalk.cyan.bold(title));
+  logSeparator();
+}
+
+/**
+ * Muestra un mensaje de progreso
+ */
+function logProgress(current, total, message) {
+  const percentage = Math.round((current / total) * 100);
+  const bar = '█'.repeat(Math.floor(percentage / 5)) + '░'.repeat(20 - Math.floor(percentage / 5));
+  console.log(`[${chalk.cyan(bar)}] ${percentage}% ${message}`);
+}
+
+/**
+ * Muestra una tabla simple
+ */
+function logTable(data) {
+  const maxKeyLength = Math.max(...data.map(item => item.key.length));
+
+  data.forEach(item => {
+    const paddedKey = item.key.padEnd(maxKeyLength + 2);
+    console.log(`  ${chalk.gray(paddedKey)} ${chalk.yellow(item.value)}`);
+  });
+}
+
+/**
+ * Muestra un mensaje de bienvenida
+ */
+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('╚═══════════════════════════════════════════════════════════╝'));
+  console.log();
+}
+
+/**
+ * Muestra comandos disponibles
+ */
+function displayCommands(commands) {
+  console.log(chalk.cyan('\n💡 Comandos disponibles:\n'));
+
+  commands.forEach(cmd => {
+    const command = chalk.green(cmd.command.padEnd(20));
+    const description = chalk.gray(cmd.description);
+    console.log(`  ${command} ${description}`);
+  });
+
+  console.log();
+}
+
+/**
+ * Muestra filosofía ZNS
+ */
+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();
+}
+
+/**
+ * Muestra banner de finalización
+ */
+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('╚═══════════════════════════════════════════════════════════╝'));
+  } else {
+    console.log(chalk.red('╔═══════════════════════════════════════════════════════════╗'));
+    console.log(chalk.red('║') + chalk.bold.white('              ❌ PROCESO FALLIDO                          ') + chalk.red('║'));
+    console.log(chalk.red('╚═══════════════════════════════════════════════════════════╝'));
+  }
+  console.log();
+}
+
+module.exports = {
+  displayLogo,
+  logSuccess,
+  logError,
+  logWarning,
+  logInfo,
+  logSeparator,
+  logSection,
+  logProgress,
+  logTable,
+  displayWelcome,
+  displayCommands,
+  displayZnsPhilosophy,
+  displayCompletionBanner
+};

package/tools/cli/utils/file-utils.js

@@ -0,0 +1,178 @@
+/**
+ * File Utilities
+ * Utilidades para manejo de archivos y directorios
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * Copia agentes desde src hacia destino
+ */
+async function copyAgents(srcPath, destPath) {
+  await fs.ensureDir(destPath);
+  await fs.copy(srcPath, destPath, {
+    overwrite: true,
+    filter: (src) => {
+      return src.endsWith('.yaml') || fs.statSync(src).isDirectory();
+    }
+  });
+}
+
+/**
+ * Copia workflows desde src hacia destino
+ */
+async function copyWorkflows(srcPath, destPath) {
+  await fs.ensureDir(destPath);
+  await fs.copy(srcPath, destPath, {
+    overwrite: true
+  });
+}
+
+/**
+ * Crea archivo de configuración en formato YAML
+ */
+async function createConfigFile(awcDir, config) {
+  const configPath = path.join(awcDir, 'config.yaml');
+  const yamlContent = yaml.dump(config, {
+    indent: 2,
+    lineWidth: 80,
+    noRefs: true
+  });
+  await fs.writeFile(configPath, yamlContent, 'utf8');
+}
+
+/**
+ * Carga configuración desde archivo YAML
+ */
+async function loadConfig(awcDir) {
+  const configPath = path.join(awcDir, 'config.yaml');
+
+  if (!(await fs.pathExists(configPath))) {
+    return null;
+  }
+
+  try {
+    const content = await fs.readFile(configPath, 'utf8');
+    return yaml.load(content);
+  } catch (error) {
+    console.error('Error al cargar configuración:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Actualiza configuración existente
+ */
+async function updateConfig(awcDir, newConfig) {
+  await createConfigFile(awcDir, newConfig);
+}
+
+/**
+ * Lee un archivo YAML
+ */
+async function readYamlFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    return yaml.load(content);
+  } catch (error) {
+    console.error(`Error al leer ${filePath}:`, error.message);
+    return null;
+  }
+}
+
+/**
+ * Escribe un archivo YAML
+ */
+async function writeYamlFile(filePath, data) {
+  const yamlContent = yaml.dump(data, {
+    indent: 2,
+    lineWidth: 80,
+    noRefs: true
+  });
+  await fs.writeFile(filePath, yamlContent, 'utf8');
+}
+
+/**
+ * Busca archivos recursivamente con un patrón
+ */
+async function findFiles(dir, pattern) {
+  const results = [];
+
+  if (!(await fs.pathExists(dir))) {
+    return results;
+  }
+
+  const items = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const item of items) {
+    const fullPath = path.join(dir, item.name);
+
+    if (item.isDirectory()) {
+      const subResults = await findFiles(fullPath, pattern);
+      results.push(...subResults);
+    } else if (item.isFile() && item.name.match(pattern)) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Cuenta archivos en un directorio recursivamente
+ */
+async function countFiles(dir, extensions = []) {
+  let count = 0;
+
+  if (!(await fs.pathExists(dir))) {
+    return count;
+  }
+
+  const items = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const item of items) {
+    const fullPath = path.join(dir, item.name);
+
+    if (item.isDirectory()) {
+      count += await countFiles(fullPath, extensions);
+    } else if (item.isFile()) {
+      if (extensions.length === 0) {
+        count++;
+      } else {
+        const ext = path.extname(item.name);
+        if (extensions.includes(ext)) {
+          count++;
+        }
+      }
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Verifica si un directorio está vacío
+ */
+async function isDirectoryEmpty(dir) {
+  if (!(await fs.pathExists(dir))) {
+    return true;
+  }
+
+  const items = await fs.readdir(dir);
+  return items.length === 0;
+}
+
+module.exports = {
+  copyAgents,
+  copyWorkflows,
+  createConfigFile,
+  loadConfig,
+  updateConfig,
+  readYamlFile,
+  writeYamlFile,
+  findFiles,
+  countFiles,
+  isDirectoryEmpty
+};