awc-zns-mtd 2.0.0

package/tools/version/changelog-manager.js

@@ -0,0 +1,288 @@
+/**
+ * Changelog Manager
+ * Gestor de changelog automático para AWC ZNS-MTD
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+class ChangelogManager {
+  constructor(changelogPath = null) {
+    this.changelogPath = changelogPath || path.join(__dirname, '../../CHANGELOG.md');
+    this.changeTypes = {
+      'added': 'Añadido',
+      'changed': 'Cambiado',
+      'deprecated': 'Obsoleto',
+      'removed': 'Eliminado',
+      'fixed': 'Corregido',
+      'security': 'Seguridad'
+    };
+  }
+
+  /**
+   * Lee el contenido del changelog
+   */
+  async readChangelog() {
+    if (!(await fs.pathExists(this.changelogPath))) {
+      return null;
+    }
+
+    try {
+      return await fs.readFile(this.changelogPath, 'utf8');
+    } catch (error) {
+      throw new Error(`Error al leer changelog: ${error.message}`);
+    }
+  }
+
+  /**
+   * Obtiene las notas de una versión específica
+   */
+  async getVersionNotes(version) {
+    const content = await this.readChangelog();
+    
+    if (!content) return null;
+
+    // Buscar sección de la versión
+    const versionRegex = new RegExp(`## \\[${version}\\]([\\s\\S]*?)(?=## \\[|$)`, 'i');
+    const match = content.match(versionRegex);
+
+    if (!match) return null;
+
+    return this.parseVersionSection(match[1]);
+  }
+
+  /**
+   * Parsea una sección de versión del changelog
+   * @private
+   */
+  parseVersionSection(section) {
+    const parsed = {
+      added: [],
+      changed: [],
+      deprecated: [],
+      removed: [],
+      fixed: [],
+      security: []
+    };
+
+    // Buscar cada tipo de cambio
+    Object.keys(this.changeTypes).forEach(type => {
+      const typeRegex = new RegExp(`### ${this.changeTypes[type]}([\\s\\S]*?)(?=###|$)`, 'i');
+      const match = section.match(typeRegex);
+
+      if (match) {
+        // Extraer items (líneas que empiezan con -)
+        const items = match[1].match(/^- (.+)$/gm) || [];
+        parsed[type] = items.map(item => item.replace(/^- /, '').trim());
+      }
+    });
+
+    return parsed;
+  }
+
+  /**
+   * Obtiene el último cambio registrado
+   */
+  async getLatestRelease() {
+    const content = await this.readChangelog();
+    
+    if (!content) return null;
+
+    // Buscar primera versión (ignorando Unreleased)
+    const versionRegex = /## \[(\d+\.\d+\.\d+)\] - (\d{4}-\d{2}-\d{2})/;
+    const match = content.match(versionRegex);
+
+    if (!match) return null;
+
+    const [, version, date] = match;
+    const notes = await this.getVersionNotes(version);
+
+    return {
+      version,
+      date,
+      notes
+    };
+  }
+
+  /**
+   * Agrega una nueva versión al changelog
+   */
+  async addVersion(version, date, changes) {
+    const content = await this.readChangelog();
+    
+    if (!content) {
+      throw new Error('Changelog no encontrado');
+    }
+
+    // Generar sección de la nueva versión
+    const versionSection = this.generateVersionSection(version, date, changes);
+
+    // Insertar después de "## [Unreleased]"
+    const unreleasedRegex = /(## \[Unreleased\][\s\S]*?)(?=## \[|$)/;
+    const newContent = content.replace(unreleasedRegex, `$1\n${versionSection}\n`);
+
+    await fs.writeFile(this.changelogPath, newContent, 'utf8');
+  }
+
+  /**
+   * Genera sección de versión en formato markdown
+   * @private
+   */
+  generateVersionSection(version, date, changes) {
+    let section = `## [${version}] - ${date}\n\n`;
+
+    // Agregar cada tipo de cambio si tiene items
+    Object.keys(this.changeTypes).forEach(type => {
+      if (changes[type] && changes[type].length > 0) {
+        section += `### ${this.changeTypes[type]}\n\n`;
+        changes[type].forEach(item => {
+          section += `- ${item}\n`;
+        });
+        section += '\n';
+      }
+    });
+
+    return section;
+  }
+
+  /**
+   * Obtiene todos los cambios no liberados (Unreleased)
+   */
+  async getUnreleasedChanges() {
+    const content = await this.readChangelog();
+    
+    if (!content) return null;
+
+    const unreleasedRegex = /## \[Unreleased\]([\s\S]*?)(?=## \[|$)/;
+    const match = content.match(unreleasedRegex);
+
+    if (!match) return null;
+
+    return this.parseVersionSection(match[1]);
+  }
+
+  /**
+   * Verifica si hay cambios breaking en una versión
+   */
+  async hasBreakingChanges(version) {
+    const notes = await this.getVersionNotes(version);
+    
+    if (!notes) return false;
+
+    // Buscar indicadores de breaking changes
+    const breakingIndicators = [
+      'BREAKING CHANGE',
+      'breaking change',
+      'incompatible',
+      'removed',
+      'deprecated'
+    ];
+
+    const allChanges = Object.values(notes).flat().join(' ').toLowerCase();
+    
+    return breakingIndicators.some(indicator => 
+      allChanges.includes(indicator.toLowerCase())
+    );
+  }
+
+  /**
+   * Genera resumen de cambios entre dos versiones
+   */
+  async getChangesSummary(fromVersion, toVersion) {
+    const content = await this.readChangelog();
+    
+    if (!content) return null;
+
+    const summary = {
+      from: fromVersion,
+      to: toVersion,
+      changes: {
+        added: [],
+        changed: [],
+        deprecated: [],
+        removed: [],
+        fixed: [],
+        security: []
+      },
+      breakingChanges: false
+    };
+
+    // Parsear todas las versiones entre fromVersion y toVersion
+    const versionRegex = /## \[(\d+\.\d+\.\d+)\]/g;
+    const versions = [];
+    let match;
+
+    while ((match = versionRegex.exec(content)) !== null) {
+      versions.push(match[1]);
+    }
+
+    // Filtrar versiones en el rango
+    const fromIndex = versions.indexOf(fromVersion);
+    const toIndex = versions.indexOf(toVersion);
+
+    if (fromIndex === -1 || toIndex === -1) {
+      return null;
+    }
+
+    const versionsInRange = versions.slice(toIndex, fromIndex);
+
+    // Agregar cambios de cada versión
+    for (const version of versionsInRange) {
+      const notes = await this.getVersionNotes(version);
+      
+      if (notes) {
+        Object.keys(notes).forEach(type => {
+          summary.changes[type].push(...notes[type]);
+        });
+
+        if (await this.hasBreakingChanges(version)) {
+          summary.breakingChanges = true;
+        }
+      }
+    }
+
+    return summary;
+  }
+
+  /**
+   * Valida formato del changelog
+   */
+  async validateChangelog() {
+    const content = await this.readChangelog();
+    
+    if (!content) {
+      return {
+        valid: false,
+        errors: ['Changelog no encontrado']
+      };
+    }
+
+    const errors = [];
+
+    // Verificar formato de versiones
+    const versionRegex = /## \[\d+\.\d+\.\d+\] - \d{4}-\d{2}-\d{2}/g;
+    if (!versionRegex.test(content)) {
+      errors.push('Formato de versión inválido');
+    }
+
+    // Verificar sección Unreleased
+    if (!content.includes('## [Unreleased]')) {
+      errors.push('Falta sección [Unreleased]');
+    }
+
+    // Verificar tipos de cambio
+    const requiredSections = Object.values(this.changeTypes);
+    // No es obligatorio tener todas las secciones, solo verificar que las que existan sean válidas
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+}
+
+// Singleton instance
+const changelogManager = new ChangelogManager();
+
+module.exports = changelogManager;
+module.exports.ChangelogManager = ChangelogManager;

package/tools/version/update-checker.js

@@ -0,0 +1,234 @@
+/**
+ * Update Checker
+ * Verifica actualizaciones disponibles del método AWC ZNS-MTD
+ */
+
+const semver = require('semver');
+const versionManager = require('./version-manager');
+
+class UpdateChecker {
+  constructor() {
+    this.currentVersion = versionManager.getCurrentVersion();
+    this.updateCheckInterval = 24 * 60 * 60 * 1000; // 24 horas
+  }
+
+  /**
+   * Verifica si hay actualizaciones disponibles
+   * @param {object} options - Opciones de verificación
+   */
+  async checkForUpdates(options = {}) {
+    const {
+      registry = 'https://registry.npmjs.org',
+      includePrerelease = false,
+      timeout = 5000
+    } = options;
+
+    try {
+      // En producción, esto consultaría el registro de npm
+      // Por ahora, simulamos la verificación
+      const latestVersion = await this.fetchLatestVersion(registry, timeout);
+
+      if (!latestVersion) {
+        return {
+          hasUpdate: false,
+          currentVersion: this.currentVersion,
+          latestVersion: this.currentVersion,
+          updateAvailable: false,
+          error: 'No se pudo obtener información de versión'
+        };
+      }
+
+      const hasUpdate = semver.gt(latestVersion, this.currentVersion);
+      const changeType = versionManager.getChangeType(this.currentVersion, latestVersion);
+
+      return {
+        hasUpdate,
+        currentVersion: this.currentVersion,
+        latestVersion,
+        updateAvailable: hasUpdate,
+        changeType,
+        severity: this.getUpdateSeverity(changeType),
+        releaseNotes: await this.getReleaseNotes(latestVersion)
+      };
+    } catch (error) {
+      return {
+        hasUpdate: false,
+        currentVersion: this.currentVersion,
+        latestVersion: this.currentVersion,
+        updateAvailable: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Obtiene la última versión disponible
+   * @private
+   */
+  async fetchLatestVersion(registry, timeout) {
+    // Simulación - en producción haría fetch real al registro
+    // const url = `${registry}/${versionManager.packageName}/latest`;
+
+    // Por ahora retornamos la versión actual
+    return this.currentVersion;
+  }
+
+  /**
+   * Obtiene las notas de lanzamiento de una versión
+   * @private
+   */
+  async getReleaseNotes(version) {
+    // En producción, esto obtendría las notas reales del changelog o GitHub releases
+    return {
+      version,
+      date: new Date().toISOString(),
+      notes: 'Consulta CHANGELOG.md para detalles completos',
+      breaking: [],
+      features: [],
+      fixes: []
+    };
+  }
+
+  /**
+   * Determina la severidad de la actualización
+   * @private
+   */
+  getUpdateSeverity(changeType) {
+    const severities = {
+      'major': 'critical',    // Breaking changes
+      'minor': 'important',   // New features
+      'patch': 'low',         // Bug fixes
+      'none': 'none'
+    };
+
+    return severities[changeType] || 'none';
+  }
+
+  /**
+   * Verifica si debe realizar check de actualización
+   * @param {Date} lastCheck - Última vez que se verificó
+   */
+  shouldCheckForUpdates(lastCheck) {
+    if (!lastCheck) return true;
+
+    const now = new Date();
+    const timeSinceLastCheck = now - new Date(lastCheck);
+
+    return timeSinceLastCheck >= this.updateCheckInterval;
+  }
+
+  /**
+   * Genera mensaje de actualización para el usuario
+   */
+  async generateUpdateMessage() {
+    const updateInfo = await this.checkForUpdates();
+
+    if (!updateInfo.hasUpdate) {
+      return {
+        hasMessage: false,
+        message: '',
+        type: 'info'
+      };
+    }
+
+    const messages = {
+      'critical': `🚨 ACTUALIZACIÓN CRÍTICA DISPONIBLE: v${updateInfo.latestVersion}\n` +
+                  `   Versión actual: v${updateInfo.currentVersion}\n` +
+                  `   Esta actualización incluye cambios importantes (breaking changes).\n` +
+                  `   Actualiza con: npm install -g awc-zns-mtd@latest`,
+
+      'important': `⚡ Nueva versión disponible: v${updateInfo.latestVersion}\n` +
+                   `   Versión actual: v${updateInfo.currentVersion}\n` +
+                   `   Incluye nuevas funcionalidades.\n` +
+                   `   Actualiza con: npm install -g awc-zns-mtd@latest`,
+
+      'low': `💡 Actualización disponible: v${updateInfo.latestVersion}\n` +
+             `   Versión actual: v${updateInfo.currentVersion}\n` +
+             `   Incluye correcciones de bugs.\n` +
+             `   Actualiza con: npm install -g awc-zns-mtd@latest`
+    };
+
+    return {
+      hasMessage: true,
+      message: messages[updateInfo.severity] || messages['low'],
+      type: updateInfo.severity,
+      updateInfo
+    };
+  }
+
+  /**
+   * Verifica compatibilidad antes de actualizar
+   */
+  async checkUpdateCompatibility(targetVersion) {
+    const changeType = versionManager.getChangeType(this.currentVersion, targetVersion);
+
+    const compatibility = {
+      canUpdate: true,
+      warnings: [],
+      breaking: [],
+      recommendations: []
+    };
+
+    // Verificar breaking changes en actualizaciones major
+    if (changeType === 'major') {
+      compatibility.warnings.push(
+        'Esta es una actualización major que puede incluir breaking changes'
+      );
+      compatibility.recommendations.push(
+        'Revisa el CHANGELOG.md antes de actualizar',
+        'Considera hacer backup de tu configuración actual',
+        'Prueba en un entorno de desarrollo primero'
+      );
+    }
+
+    // Verificar compatibilidad de Node.js
+    const requiredNode = versionManager.getVersionInfo().compatibility?.minimumNodeVersion;
+    if (requiredNode) {
+      compatibility.recommendations.push(
+        `Asegúrate de tener Node.js ${requiredNode} o superior`
+      );
+    }
+
+    return compatibility;
+  }
+
+  /**
+   * Obtiene historial de versiones
+   */
+  async getVersionHistory(limit = 10) {
+    // En producción, esto consultaría el registro real
+    return {
+      current: this.currentVersion,
+      history: [
+        {
+          version: '1.0.0',
+          date: '2026-01-07',
+          type: 'major',
+          notes: 'Lanzamiento inicial'
+        }
+      ],
+      total: 1
+    };
+  }
+
+  /**
+   * Verifica si la versión actual está deprecada
+   */
+  async isVersionDeprecated() {
+    const updateInfo = await this.checkForUpdates();
+
+    if (!updateInfo.hasUpdate) return false;
+
+    // Versión deprecada si hay 2+ major versions de diferencia
+    const majorDiff = semver.major(updateInfo.latestVersion) -
+                     semver.major(this.currentVersion);
+
+    return majorDiff >= 2;
+  }
+}
+
+// Singleton instance
+const updateChecker = new UpdateChecker();
+
+module.exports = updateChecker;
+module.exports.UpdateChecker = UpdateChecker;

package/tools/version/version-bump.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * Version Bump Script
+ * Script para incrementar versión del proyecto AWC ZNS-MTD
+ * 
+ * Uso:
+ *   node version-bump.js <major|minor|patch> [--message "mensaje"]
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const versionManager = require('./version-manager');
+const changelogManager = require('./changelog-manager');
+
+async function bumpVersion() {
+  // Parsear argumentos
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0) {
+    console.error('❌ Uso: node version-bump.js <major|minor|patch> [--message "mensaje"]');
+    process.exit(1);
+  }
+
+  const bumpType = args[0];
+  const validTypes = ['major', 'minor', 'patch'];
+
+  if (!validTypes.includes(bumpType)) {
+    console.error(`❌ Tipo inválido: ${bumpType}`);
+    console.error(`   Tipos válidos: ${validTypes.join(', ')}`);
+    process.exit(1);
+  }
+
+  // Obtener mensaje personalizado si existe
+  const messageIndex = args.indexOf('--message');
+  const customMessage = messageIndex !== -1 ? args[messageIndex + 1] : null;
+
+  try {
+    console.log('🚀 Incrementando versión...\n');
+
+    // Obtener versión actual
+    const currentVersion = versionManager.getCurrentVersion();
+    console.log(`   Versión actual: ${currentVersion}`);
+
+    // Calcular nueva versión
+    const newVersion = versionManager.incrementVersion(bumpType);
+    console.log(`   Nueva versión:  ${newVersion}`);
+    console.log(`   Tipo de cambio: ${bumpType}\n`);
+
+    // Actualizar package.json
+    const packageJsonPath = path.join(__dirname, '../../package.json');
+    const packageJson = await fs.readJSON(packageJsonPath);
+    packageJson.version = newVersion;
+    await fs.writeJSON(packageJsonPath, packageJson, { spaces: 2 });
+    console.log('✓ package.json actualizado');
+
+    // Generar entrada de changelog
+    const date = new Date().toISOString().split('T')[0];
+    const changes = {
+      added: [],
+      changed: [`Versión incrementada de ${currentVersion} a ${newVersion}`],
+      deprecated: [],
+      removed: [],
+      fixed: [],
+      security: []
+    };
+
+    if (customMessage) {
+      changes.added.push(customMessage);
+    }
+
+    await changelogManager.addVersion(newVersion, date, changes);
+    console.log('✓ CHANGELOG.md actualizado');
+
+    // Resumen
+    console.log('\n✅ Versión incrementada exitosamente\n');
+    console.log('📋 Próximos pasos:');
+    console.log('   1. Revisa los cambios en CHANGELOG.md');
+    console.log('   2. Commit: git add . && git commit -m "chore: bump version to ' + newVersion + '"');
+    console.log('   3. Tag: git tag -a v' + newVersion + ' -m "Release v' + newVersion + '"');
+    console.log('   4. Push: git push && git push --tags\n');
+
+  } catch (error) {
+    console.error('❌ Error al incrementar versión:', error.message);
+    process.exit(1);
+  }
+}
+
+// Ejecutar
+bumpVersion();