siesa-agents 2.0.0 → 2.1.0

package/bin/install.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs-extra');
 const path = require('path');
+const readline = require('readline');
 
 class SiesaBmadInstaller {
   constructor() {
@@ -16,6 +17,17 @@ class SiesaBmadInstaller {
     this.packageDir = this.findPackageDir();
   }
 
+  showBanner() {
+    console.log('\n');
+    console.log('███████╗██╗███████╗███████╗ █████╗      █████╗  ██████╗ ███████╗███╗   ██╗████████╗███████╗');
+    console.log('██╔════╝██║██╔════╝██╔════╝██╔══██╗    ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝██╔════╝');
+    console.log('███████╗██║█████╗  ███████╗███████║    ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║   ███████╗');
+    console.log('╚════██║██║██╔══╝  ╚════██║██╔══██║    ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   ╚════██║');
+    console.log('███████║██║███████╗███████║██║  ██║    ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ███████║');
+    console.log('╚══════╝╚═╝╚══════╝╚══════╝╚═╝  ╚═╝    ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝');
+    console.log('');
+  }
+
   findPackageDir() {
     // Opción 1: directorio padre del bin (instalación normal)
     let packageDir = path.dirname(__dirname);
@@ -32,18 +44,14 @@ class SiesaBmadInstaller {
         process.cwd(), // directorio actual como último recurso
       ];
 
-      console.log('🔍 Buscando paquete en ubicaciones alternativas...');
       for (const possiblePath of possiblePaths) {
-        console.log(`   Probando: ${possiblePath}`);
         if (this.hasRequiredFolders(possiblePath)) {
-          console.log(`   ✅ Encontrado en: ${possiblePath}`);
           packageDir = possiblePath;
           break;
         }
       }
     }
 
-    console.log(`🎯 Directorio del paquete seleccionado: ${packageDir}`);
     return packageDir;
   }
 
@@ -55,9 +63,8 @@ class SiesaBmadInstaller {
   }
 
   async install() {
-    console.log('🔍 Directorio del paquete:', this.packageDir);
-    console.log('🚀 Instalando SIESA BMAD Agents...');
-    console.log(`📁 Directorio de destino: ${this.targetDir}`);
+    this.showBanner();
+    console.log(' Instalando SIESA Agents...');
 
     try {
       // Verificar si ya existe una instalación
@@ -71,7 +78,7 @@ class SiesaBmadInstaller {
         await this.performInstallation();
       }
 
-      console.log('✅ SIESA BMAD Agents instalado correctamente!');
+      console.log('✅ SIESA Agents instalado correctamente!');
       this.showPostInstallMessage();
 
     } catch (error) {
@@ -87,28 +94,241 @@ class SiesaBmadInstaller {
     });
   }
 
-  async performInstallation() {
-    // Debug: listar contenido del directorio del paquete
-    console.log('🔍 Contenido del directorio del paquete:');
-    try {
-      const packageContents = await fs.readdir(this.packageDir);
-      console.log('📋 Archivos/carpetas encontrados:', packageContents);
-    } catch (error) {
-      console.log('❌ Error leyendo directorio del paquete:', error.message);
+  async checkModifiedFiles() {
+    const modifiedFiles = [];
+
+    for (const mapping of this.folderMappings) {
+      const sourcePath = path.join(this.packageDir, mapping.source);
+      const targetPath = path.join(this.targetDir, mapping.target);
+
+      if (!fs.existsSync(sourcePath) || !fs.existsSync(targetPath)) {
+        continue;
+      }
+
+      // Obtener todos los archivos recursivamente
+      const sourceFiles = await this.getAllFiles(sourcePath);
+
+      for (const sourceFile of sourceFiles) {
+        const relativePath = path.relative(sourcePath, sourceFile);
+        const targetFile = path.join(targetPath, relativePath);
+
+        if (fs.existsSync(targetFile)) {
+          try {
+            // Comparar contenido de archivos
+            const sourceContent = await fs.readFile(sourceFile, 'utf8');
+            const targetContent = await fs.readFile(targetFile, 'utf8');
+
+            if (sourceContent !== targetContent) {
+              modifiedFiles.push({
+                folder: mapping.target,
+                file: relativePath,
+                fullPath: targetFile
+              });
+            }
+          } catch (error) {
+            // Si no se puede leer como texto, comparar como buffer (archivos binarios)
+            const sourceBuffer = await fs.readFile(sourceFile);
+            const targetBuffer = await fs.readFile(targetFile);
+
+            if (!sourceBuffer.equals(targetBuffer)) {
+              modifiedFiles.push({
+                folder: mapping.target,
+                file: relativePath,
+                fullPath: targetFile
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return modifiedFiles;
+  }
+
+  async getAllFiles(dir) {
+    const files = [];
+    const items = await fs.readdir(dir);
+
+    for (const item of items) {
+      const fullPath = path.join(dir, item);
+      const stat = await fs.stat(fullPath);
+
+      if (stat.isDirectory()) {
+        const subFiles = await this.getAllFiles(fullPath);
+        files.push(...subFiles);
+      } else {
+        files.push(fullPath);
+      }
+    }
+
+    return files;
+  }
+
+  async promptUser(modifiedFiles) {
+    console.log('\n⚠️  Se detectaron archivos modificados:');
+
+    // Agrupar por carpeta
+    const filesByFolder = {};
+    modifiedFiles.forEach(item => {
+      if (!filesByFolder[item.folder]) {
+        filesByFolder[item.folder] = [];
+      }
+      filesByFolder[item.folder].push(item.file);
+    });
+
+    // Mostrar archivos modificados por carpeta
+    Object.keys(filesByFolder).forEach(folder => {
+      console.log(`\n📁 ${folder}:`);
+      filesByFolder[folder].forEach(file => {
+        console.log(`   - ${file}`);
+      });
+    });
+
+    console.log('\n¿Qué deseas hacer?');
+    console.log('1. Reemplazar todos los archivos (se perderán las modificaciones)');
+    console.log('2. Hacer backup de archivos modificados (se agregarán con sufijo _bk)');
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+      rl.question('\nElige una opción (1 o 2): ', (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+
+  async backupModifiedFiles(modifiedFiles) {
+    console.log('\n🔄 Creando backup de archivos modificados...');
+
+    for (const item of modifiedFiles) {
+      const originalPath = item.fullPath;
+      const backupPath = this.getBackupPath(originalPath);
+
+      try {
+        await fs.copy(originalPath, backupPath);
+        
+        // Determinar tipo de backup para mostrar mensaje apropiado
+        const backupName = path.basename(backupPath);
+        const isVersionedBackup = backupName.includes('_bk_');
+        
+        if (isVersionedBackup) {
+          console.log(`✓ Backup versionado: ${path.relative(this.targetDir, backupPath)}`);
+        } else {
+          console.log(`✓ Backup creado: ${path.relative(this.targetDir, backupPath)}`);
+        }
+      } catch (error) {
+        console.warn(`⚠️  Error creando backup de ${item.file}: ${error.message}`);
+      }
+    }
+  }
+
+  getBackupPath(filePath) {
+    const dir = path.dirname(filePath);
+    const ext = path.extname(filePath);
+    const name = path.basename(filePath, ext);
+
+    // Primer intento: archivo_bk.ext
+    const basicBackupPath = path.join(dir, `${name}_bk${ext}`);
+    
+    // Si no existe, usar el nombre básico
+    if (!fs.existsSync(basicBackupPath)) {
+      return basicBackupPath;
     }
 
+    // Si ya existe _bk, crear versión con timestamp
+    const now = new Date();
+    const timestamp = now.getFullYear().toString() +
+                     (now.getMonth() + 1).toString().padStart(2, '0') +
+                     now.getDate().toString().padStart(2, '0') + '_' +
+                     now.getHours().toString().padStart(2, '0') +
+                     now.getMinutes().toString().padStart(2, '0') +
+                     now.getSeconds().toString().padStart(2, '0');
+    
+    return path.join(dir, `${name}_bk_${timestamp}${ext}`);
+  }
+
+  async performUpdateWithBackups() {
+    for (const mapping of this.folderMappings) {
+      const sourcePath = path.join(this.packageDir, mapping.source);
+      const targetPath = path.join(this.targetDir, mapping.target);
+
+      if (fs.existsSync(sourcePath)) {
+        // Copiar archivos selectivamente, preservando los _bk
+        await this.copyWithBackupPreservation(sourcePath, targetPath);
+      } else {
+        console.warn(`⚠️  Carpeta ${mapping.source} no encontrada en el paquete`);
+      }
+    }
+  }
+
+  async copyWithBackupPreservation(sourcePath, targetPath) {
+    // Obtener todos los archivos backup existentes
+    const backupFiles = await this.findBackupFiles(targetPath);
+    
+    // Copiar la carpeta completa sobrescribiendo
+    await fs.copy(sourcePath, targetPath, {
+      overwrite: true,
+      recursive: true
+    });
+
+    // Restaurar los archivos backup
+    for (const backupFile of backupFiles) {
+      const backupSourcePath = backupFile.tempPath;
+      const backupTargetPath = backupFile.originalPath;
+      
+      try {
+        await fs.copy(backupSourcePath, backupTargetPath);
+        // Limpiar archivo temporal
+        await fs.remove(backupSourcePath);
+      } catch (error) {
+        console.warn(`⚠️  Error restaurando backup ${backupFile.relativePath}: ${error.message}`);
+      }
+    }
+  }
+
+  async findBackupFiles(targetPath) {
+    if (!fs.existsSync(targetPath)) {
+      return [];
+    }
+
+    const backupFiles = [];
+    const allFiles = await this.getAllFiles(targetPath);
+
+    for (const filePath of allFiles) {
+      const fileName = path.basename(filePath);
+      // Detectar archivos _bk y _bk_timestamp
+      if (fileName.includes('_bk')) {
+        const tempPath = path.join(require('os').tmpdir(), `backup_${Date.now()}_${fileName}`);
+        const relativePath = path.relative(targetPath, filePath);
+        
+        // Crear copia temporal del backup
+        await fs.copy(filePath, tempPath);
+        
+        backupFiles.push({
+          originalPath: filePath,
+          tempPath: tempPath,
+          relativePath: relativePath
+        });
+      }
+    }
+
+    return backupFiles;
+  }
+
+  async performInstallation() {
     for (const mapping of this.folderMappings) {
       const sourcePath = path.join(this.packageDir, mapping.source);
       const targetPath = path.join(this.targetDir, mapping.target);
 
-      console.log(`🔍 Buscando: ${sourcePath}`);
       if (fs.existsSync(sourcePath)) {
-        console.log(`📋 Copiando ${mapping.source} -> ${mapping.target}...`);
         await fs.copy(sourcePath, targetPath, {
           overwrite: true,
           recursive: true
         });
-        console.log(`✓ ${mapping.target} copiado exitosamente`);
       } else {
         console.warn(`⚠️  Carpeta ${mapping.source} no encontrada en el paquete`);
       }
@@ -116,19 +336,44 @@ class SiesaBmadInstaller {
   }
 
   async update() {
-    // Crear backup de archivos existentes si es necesario
-    for (const mapping of this.folderMappings) {
-      const targetPath = path.join(this.targetDir, mapping.target);
+    // Verificar archivos modificados
+    console.log('🔍 Verificando archivos modificados...');
+    const modifiedFiles = await this.checkModifiedFiles();
 
-      if (fs.existsSync(targetPath)) {
-        console.log(`🔄 Actualizando ${mapping.target}...`);
-        // Remover carpeta existente
-        await fs.remove(targetPath);
+    let hasBackups = false;
+    if (modifiedFiles.length > 0) {
+      const userChoice = await this.promptUser(modifiedFiles);
+
+      if (userChoice === '2') {
+        // Crear backup de archivos modificados
+        await this.backupModifiedFiles(modifiedFiles);
+        hasBackups = true;
+      } else if (userChoice !== '1') {
+        console.log('❌ Opción no válida. Cancelando actualización.');
+        return;
       }
+
+      console.log('\n🔄 Procediendo con la actualización...');
+    } else {
+      console.log('✓ No se detectaron archivos modificados.');
     }
 
-    // Realizar instalación nueva
-    await this.performInstallation();
+    // Si hay backups, hacer actualización preservando backups
+    if (hasBackups) {
+      await this.performUpdateWithBackups();
+    } else {
+      // Si no hay backups, hacer actualización normal (remover y copiar)
+      for (const mapping of this.folderMappings) {
+        const targetPath = path.join(this.targetDir, mapping.target);
+
+        if (fs.existsSync(targetPath)) {
+          await fs.remove(targetPath);
+        }
+      }
+
+      // Realizar instalación nueva
+      await this.performInstallation();
+    }
   }
 
   showPostInstallMessage() {

package/bmad-core/agents/dev.md

@@ -1,7 +1,7 @@
 <!-- Powered by BMAD™ Core -->
 
 # dev
-
+hola papu
 ACTIVATION-NOTICE: This file contains your full agent operating guidelines. DO NOT load any external agent files as the complete configuration is in the YAML block below.
 
 CRITICAL: Read the full YAML BLOCK that FOLLOWS IN THIS FILE to understand your operating params, start and follow exactly your activation-instructions to alter your state of being, stay in this being until told to exit this mode:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "siesa-agents",
-  "version": "2.0.0",
-  "description": "Paquete para instalar y configurar agentes SIESA BMAD en tu proyecto",
+  "version": "2.1.0",
+  "description": "Paquete para instalar y configurar agentes SIESA en tu proyecto",
   "main": "index.js",
   "bin": {
     "siesa-agents": "./bin/install.js"