awc-zns-mtd 2.0.0

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

@@ -0,0 +1,280 @@
+/**
+ * Project Analyzer
+ * Analiza proyectos para determinar workflow recomendado
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { countFiles, findFiles } = require('./file-utils');
+
+/**
+ * Analiza un proyecto y retorna información relevante
+ */
+async function analyzeProject(projectPath) {
+  const analysis = {
+    technologies: [],
+    languages: [],
+    fileCount: 0,
+    directoryCount: 0,
+    complexity: 'medium',
+    size: 'medium',
+    hasTests: false,
+    hasDocs: false,
+    buildTools: []
+  };
+
+  try {
+    // Detectar tecnologías por archivos de configuración
+    analysis.technologies = await detectTechnologies(projectPath);
+
+    // Detectar lenguajes
+    analysis.languages = await detectLanguages(projectPath);
+
+    // Contar archivos
+    analysis.fileCount = await countFiles(projectPath);
+
+    // Contar directorios
+    analysis.directoryCount = await countDirectories(projectPath);
+
+    // Detectar tests
+    analysis.hasTests = await hasTestDirectory(projectPath);
+
+    // Detectar documentación
+    analysis.hasDocs = await hasDocsDirectory(projectPath);
+
+    // Detectar build tools
+    analysis.buildTools = await detectBuildTools(projectPath);
+
+    // Calcular complejidad
+    analysis.complexity = calculateComplexity(analysis);
+
+    // Calcular tamaño
+    analysis.size = calculateSize(analysis);
+
+  } catch (error) {
+    console.error('Error en análisis:', error.message);
+  }
+
+  return analysis;
+}
+
+/**
+ * Detecta tecnologías basándose en archivos de configuración
+ */
+async function detectTechnologies(projectPath) {
+  const technologies = [];
+
+  const techMarkers = {
+    'package.json': ['Node.js', 'npm'],
+    'yarn.lock': ['Yarn'],
+    'pnpm-lock.yaml': ['pnpm'],
+    'requirements.txt': ['Python', 'pip'],
+    'Pipfile': ['Python', 'Pipenv'],
+    'pyproject.toml': ['Python', 'Poetry'],
+    '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'],
+    'docker-compose.yml': ['Docker Compose'],
+    '.gitignore': ['Git'],
+    'tsconfig.json': ['TypeScript'],
+    'angular.json': ['Angular'],
+    'next.config.js': ['Next.js'],
+    'nuxt.config.js': ['Nuxt.js'],
+    'vue.config.js': ['Vue.js'],
+    'svelte.config.js': ['Svelte'],
+    'gatsby-config.js': ['Gatsby'],
+    'vite.config.js': ['Vite']
+  };
+
+  for (const [file, techs] of Object.entries(techMarkers)) {
+    if (await fs.pathExists(path.join(projectPath, file))) {
+      technologies.push(...techs);
+    }
+  }
+
+  return [...new Set(technologies)]; // Eliminar duplicados
+}
+
+/**
+ * Detecta lenguajes de programación
+ */
+async function detectLanguages(projectPath) {
+  const languages = new Set();
+
+  const languageExtensions = {
+    '.js': 'JavaScript',
+    '.jsx': 'JavaScript',
+    '.ts': 'TypeScript',
+    '.tsx': 'TypeScript',
+    '.py': 'Python',
+    '.java': 'Java',
+    '.rb': 'Ruby',
+    '.php': 'PHP',
+    '.go': 'Go',
+    '.rs': 'Rust',
+    '.cs': 'C#',
+    '.cpp': 'C++',
+    '.c': 'C',
+    '.swift': 'Swift',
+    '.kt': 'Kotlin'
+  };
+
+  for (const [ext, lang] of Object.entries(languageExtensions)) {
+    const files = await findFiles(projectPath, new RegExp(`\\${ext}$`));
+    if (files.length > 0) {
+      languages.add(lang);
+    }
+  }
+
+  return Array.from(languages);
+}
+
+/**
+ * Cuenta directorios recursivamente
+ */
+async function countDirectories(dir, depth = 0, maxDepth = 10) {
+  let count = 0;
+
+  if (depth > maxDepth || !(await fs.pathExists(dir))) {
+    return count;
+  }
+
+  const items = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const item of items) {
+    if (item.isDirectory() && !shouldIgnoreDirectory(item.name)) {
+      count++;
+      const subPath = path.join(dir, item.name);
+      count += await countDirectories(subPath, depth + 1, maxDepth);
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Verifica si existe directorio de tests
+ */
+async function hasTestDirectory(projectPath) {
+  const testDirs = ['test', 'tests', '__tests__', 'spec', 'specs'];
+
+  for (const dir of testDirs) {
+    if (await fs.pathExists(path.join(projectPath, dir))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Verifica si existe directorio de documentación
+ */
+async function hasDocsDirectory(projectPath) {
+  const docsDirs = ['docs', 'documentation', 'doc'];
+
+  for (const dir of docsDirs) {
+    if (await fs.pathExists(path.join(projectPath, dir))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Detecta herramientas de build
+ */
+async function detectBuildTools(projectPath) {
+  const buildTools = [];
+
+  const buildMarkers = {
+    'webpack.config.js': 'Webpack',
+    'rollup.config.js': 'Rollup',
+    'gulpfile.js': 'Gulp',
+    'Gruntfile.js': 'Grunt',
+    'Makefile': 'Make',
+    'CMakeLists.txt': 'CMake'
+  };
+
+  for (const [file, tool] of Object.entries(buildMarkers)) {
+    if (await fs.pathExists(path.join(projectPath, file))) {
+      buildTools.push(tool);
+    }
+  }
+
+  return buildTools;
+}
+
+/**
+ * Calcula la complejidad del proyecto
+ */
+function calculateComplexity(analysis) {
+  const { fileCount, directoryCount, technologies } = 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;
+
+  // Basado en cantidad de directorios
+  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;
+
+  // Determinar nivel de complejidad
+  if (score >= 5) return 'high';
+  if (score >= 3) return 'medium';
+  return 'low';
+}
+
+/**
+ * Calcula el tamaño del proyecto
+ */
+function calculateSize(analysis) {
+  const { fileCount } = analysis;
+
+  if (fileCount > 1000) return 'large';
+  if (fileCount > 100) return 'medium';
+  return 'small';
+}
+
+/**
+ * Determina si un directorio debe ignorarse
+ */
+function shouldIgnoreDirectory(dirName) {
+  const ignoreDirs = [
+    'node_modules',
+    '.git',
+    '.awc',
+    'dist',
+    'build',
+    'out',
+    'target',
+    'vendor',
+    '__pycache__',
+    '.venv',
+    'venv',
+    'env'
+  ];
+
+  return ignoreDirs.includes(dirName);
+}
+
+module.exports = {
+  analyzeProject,
+  detectTechnologies,
+  detectLanguages,
+  calculateComplexity,
+  calculateSize
+};

package/tools/cli/utils/version.js

@@ -0,0 +1,126 @@
+/**
+ * Version Utilities
+ * Utilidades para manejo de versiones y actualizaciones
+ */
+
+const semver = require('semver');
+const packageJson = require('../../../package.json');
+
+/**
+ * Obtiene la versión actual del paquete
+ */
+function getVersion() {
+  return packageJson.version;
+}
+
+/**
+ * Verifica si hay actualizaciones disponibles
+ * @param {string} currentVersion - Versión actual
+ * @returns {Promise<{hasUpdate: boolean, latestVersion: string}>}
+ */
+async function checkForUpdates(currentVersion) {
+  try {
+    // En producción, esto consultaría el registro de npm
+    // Por ahora, simulamos que no hay actualización
+    const latestVersion = currentVersion;
+
+    const hasUpdate = semver.gt(latestVersion, currentVersion);
+
+    return {
+      hasUpdate,
+      latestVersion,
+      currentVersion
+    };
+  } catch (error) {
+    // Si falla la verificación (ej: sin internet), retornamos sin actualización
+    return {
+      hasUpdate: false,
+      latestVersion: currentVersion,
+      currentVersion,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Compara dos versiones
+ * @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;
+  return 0;
+}
+
+/**
+ * Valida si una versión es válida según semver
+ */
+function isValidVersion(version) {
+  return semver.valid(version) !== null;
+}
+
+/**
+ * Obtiene la versión mayor (major)
+ */
+function getMajorVersion(version) {
+  return semver.major(version);
+}
+
+/**
+ * Obtiene la versión menor (minor)
+ */
+function getMinorVersion(version) {
+  return semver.minor(version);
+}
+
+/**
+ * Obtiene la versión de parche (patch)
+ */
+function getPatchVersion(version) {
+  return semver.patch(version);
+}
+
+/**
+ * Verifica si la versión satisface un rango
+ */
+function satisfiesRange(version, range) {
+  return semver.satisfies(version, range);
+}
+
+/**
+ * Incrementa la versión
+ * @param {string} version - Versión actual
+ * @param {string} type - Tipo de incremento: 'major', 'minor', 'patch'
+ */
+function incrementVersion(version, type = 'patch') {
+  return semver.inc(version, type);
+}
+
+/**
+ * Obtiene información detallada de la versión
+ */
+function getVersionInfo() {
+  const version = getVersion();
+
+  return {
+    version,
+    major: getMajorVersion(version),
+    minor: getMinorVersion(version),
+    patch: getPatchVersion(version),
+    name: packageJson.name,
+    description: packageJson.description
+  };
+}
+
+module.exports = {
+  getVersion,
+  checkForUpdates,
+  compareVersions,
+  isValidVersion,
+  getMajorVersion,
+  getMinorVersion,
+  getPatchVersion,
+  satisfiesRange,
+  incrementVersion,
+  getVersionInfo
+};

package/tools/version/README.md

@@ -0,0 +1,272 @@
+# Sistema de Versiones AWC ZNS-MTD
+
+## Descripción
+
+Sistema integral de gestión de versiones para el método AWC ZNS-MTD, basado en [Semantic Versioning 2.0.0](https://semver.org/lang/es/).
+
+## Componentes
+
+### 1. Version Manager (`version-manager.js`)
+
+Gestor central de versiones del sistema.
+
+**Funcionalidades:**
+- Obtener versión actual
+- Comparar versiones
+- Verificar compatibilidad
+- Incrementar versiones
+- Validar formatos de versión
+
+**Uso:**
+```javascript
+const versionManager = require('./version-manager');
+
+// Obtener versión actual
+const version = versionManager.getCurrentVersion();
+
+// Comparar versiones
+const comparison = versionManager.compareVersions('1.0.0', '1.1.0');
+
+// Verificar compatibilidad
+const compatible = versionManager.isCompatible('^1.0.0');
+
+// Incrementar versión
+const newVersion = versionManager.incrementVersion('minor');
+```
+
+### 2. Update Checker (`update-checker.js`)
+
+Verificador de actualizaciones disponibles.
+
+**Funcionalidades:**
+- Verificar actualizaciones en registro npm
+- Determinar severidad de actualizaciones
+- Generar mensajes de actualización
+- Verificar compatibilidad de actualizaciones
+- Detectar versiones deprecadas
+
+**Uso:**
+```javascript
+const updateChecker = require('./update-checker');
+
+// Verificar actualizaciones
+const update = await updateChecker.checkForUpdates();
+
+if (update.hasUpdate) {
+  console.log(`Nueva versión: ${update.latestVersion}`);
+  console.log(`Severidad: ${update.severity}`);
+}
+```
+
+### 3. Changelog Manager (`changelog-manager.js`)
+
+Gestor de changelog automático.
+
+**Funcionalidades:**
+- Leer y parsear CHANGELOG.md
+- Obtener notas de versiones específicas
+- Agregar nuevas versiones
+- Detectar breaking changes
+- Generar resúmenes de cambios
+
+**Uso:**
+```javascript
+const changelogManager = require('./changelog-manager');
+
+// Obtener última versión
+const latest = await changelogManager.getLatestRelease();
+
+// Agregar nueva versión
+await changelogManager.addVersion('1.1.0', '2026-01-07', {
+  added: ['Nueva funcionalidad X'],
+  fixed: ['Bug en componente Y']
+});
+```
+
+### 4. Version Bump Script (`version-bump.js`)
+
+Script CLI para incrementar versiones.
+
+**Uso:**
+```bash
+# Incrementar versión patch (1.0.0 → 1.0.1)
+node tools/version/version-bump.js patch
+
+# Incrementar versión minor (1.0.1 → 1.1.0)
+node tools/version/version-bump.js minor
+
+# Incrementar versión major (1.1.0 → 2.0.0)
+node tools/version/version-bump.js major
+
+# Con mensaje personalizado
+node tools/version/version-bump.js minor --message "Nueva funcionalidad de análisis"
+```
+
+## Semantic Versioning
+
+Formato: `MAJOR.MINOR.PATCH`
+
+- **MAJOR**: Cambios incompatibles en la API (breaking changes)
+- **MINOR**: Nuevas funcionalidades compatibles con versiones anteriores
+- **PATCH**: Correcciones de bugs compatibles
+
+### Cuándo incrementar cada versión:
+
+**MAJOR (1.0.0 → 2.0.0)**
+- Cambios en la estructura de agentes que requieren migración
+- Modificaciones en formato de workflows
+- Cambios en CLI que rompen scripts existentes
+- Eliminación de funcionalidades
+
+**MINOR (1.0.0 → 1.1.0)**
+- Nuevos agentes
+- Nuevos workflows
+- Nuevos comandos CLI
+- Nuevas funcionalidades sin breaking changes
+
+**PATCH (1.0.0 → 1.0.1)**
+- Corrección de bugs
+- Mejoras de rendimiento
+- Correcciones de documentación
+- Refactorizaciones internas
+
+## Flujo de Trabajo de Versionado
+
+### 1. Durante el Desarrollo
+
+```bash
+# Trabajar en rama feature/nueva-funcionalidad
+git checkout -b feature/nueva-funcionalidad
+
+# Hacer commits descriptivos
+git commit -m "feat: agregar nuevo agente DevOps"
+git commit -m "fix: corregir validación en workflow"
+```
+
+### 2. Preparar Release
+
+```bash
+# Ejecutar script de bump
+node tools/version/version-bump.js minor --message "Nuevo agente DevOps"
+
+# Revisar cambios generados
+git diff package.json CHANGELOG.md
+
+# Commit de versión
+git add .
+git commit -m "chore: bump version to 1.1.0"
+```
+
+### 3. Publicar Release
+
+```bash
+# Crear tag
+git tag -a v1.1.0 -m "Release v1.1.0"
+
+# Push con tags
+git push origin main
+git push origin v1.1.0
+
+# Publicar en npm (si aplica)
+npm publish
+```
+
+## Integración con CLI
+
+El sistema de versiones está integrado en los comandos CLI:
+
+```bash
+# Ver versión actual y verificar actualizaciones
+awc version
+
+# Durante instalación, verifica versión compatible
+awc install
+```
+
+## Formato de CHANGELOG.md
+
+```markdown
+# Changelog
+
+## [Unreleased]
+### Añadido
+- Funcionalidad en desarrollo
+
+## [1.1.0] - 2026-01-07
+### Añadido
+- Nuevo agente DevOps
+- Comandos de infraestructura
+
+### Corregido
+- Bug en validación de workflow
+
+## [1.0.0] - 2026-01-07
+### Añadido
+- Lanzamiento inicial
+```
+
+## Tipos de Cambios
+
+- **Añadido**: Nuevas funcionalidades
+- **Cambiado**: Cambios en funcionalidades existentes
+- **Obsoleto**: Funcionalidades deprecadas
+- **Eliminado**: Funcionalidades removidas
+- **Corregido**: Corrección de bugs
+- **Seguridad**: Parches de seguridad
+
+## Verificación de Actualizaciones
+
+El sistema verifica automáticamente actualizaciones cada 24 horas y muestra mensajes según severidad:
+
+- 🚨 **CRÍTICA**: Breaking changes (major)
+- ⚡ **IMPORTANTE**: Nuevas funcionalidades (minor)
+- 💡 **BAJA**: Correcciones de bugs (patch)
+
+## Compatibilidad
+
+El sistema garantiza compatibilidad dentro del mismo MAJOR version:
+
+- Versión `1.x.x` es compatible con `1.y.z`
+- Versión `2.x.x` puede tener breaking changes respecto a `1.x.x`
+
+## Requerimientos de Sistema
+
+Especificados en `package.json`:
+
+```json
+{
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=9.0.0"
+  }
+}
+```
+
+## Scripts de Mantenimiento
+
+Agregados a `package.json`:
+
+```json
+{
+  "scripts": {
+    "version:bump:major": "node tools/version/version-bump.js major",
+    "version:bump:minor": "node tools/version/version-bump.js minor",
+    "version:bump:patch": "node tools/version/version-bump.js patch",
+    "version:check": "awc version"
+  }
+}
+```
+
+## Mejores Prácticas
+
+1. **Siempre actualizar CHANGELOG.md** con cada cambio significativo
+2. **Usar commits convencionales** (feat:, fix:, chore:, etc.)
+3. **Verificar compatibilidad** antes de incrementar major version
+4. **Documentar breaking changes** claramente en CHANGELOG
+5. **Mantener versiones en sync** entre package.json y sistema
+6. **Probar actualizaciones** en entorno de desarrollo primero
+7. **Comunicar cambios** al equipo antes de releases major
+
+## Soporte
+
+Para más información sobre versionado semántico: https://semver.org/lang/es/