g360-cli 1.4.0 → 1.6.0

package/src/lib/global-config.js

@@ -0,0 +1,260 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { logger } from './logger.js';
+
+/**
+ * @typedef {Object} GlobalConfig
+ * @property {string} defaultSkill - Skill por defecto
+ * @property {string} defaultTemplate - Plantilla por defecto
+ * @property {Object} preferences - Preferencias del usuario
+ * @property {string[]} recentProjects - Proyectos recientes
+ * @property {Object} cache - Configuración de caché
+ */
+
+/**
+ * Ruta del directorio de configuración global
+ * @type {string}
+ */
+const G360_CONFIG_DIR = path.join(os.homedir(), '.g360');
+
+/**
+ * Ruta del archivo de configuración global
+ * @type {string}
+ */
+const G360_CONFIG_FILE = path.join(G360_CONFIG_DIR, 'config.json');
+
+/**
+ * Configuración por defecto
+ * @type {GlobalConfig}
+ */
+const DEFAULT_CONFIG = {
+  defaultSkill: 'corporativo-movil',
+  defaultTemplate: 'web-pwa',
+  preferences: {
+    language: 'es',
+    theme: 'dark',
+    verbose: false
+  },
+  recentProjects: [],
+  cache: {
+    enabled: true,
+    maxSize: 100
+  }
+};
+
+/**
+ * Módulo de configuración global para G360-CLI
+ * @namespace globalConfig
+ */
+export const globalConfig = {
+  /**
+   * Obtiene la ruta del directorio de configuración
+   * @returns {string} Ruta del directorio de configuración
+   * @example
+   * const configDir = globalConfig.getConfigDir();
+   * console.log('Config dir:', configDir);
+   */
+  getConfigDir() {
+    return G360_CONFIG_DIR;
+  },
+
+  /**
+   * Obtiene la ruta del archivo de configuración
+   * @returns {string} Ruta del archivo de configuración
+   * @example
+   * const configFile = globalConfig.getConfigFile();
+   * console.log('Config file:', configFile);
+   */
+  getConfigFile() {
+    return G360_CONFIG_FILE;
+  },
+
+  /**
+   * Inicializa el directorio de configuración global
+   * @returns {Promise<void>}
+   * @example
+   * await globalConfig.init();
+   */
+  async init() {
+    try {
+      await fs.ensureDir(G360_CONFIG_DIR);
+      
+      if (!fs.existsSync(G360_CONFIG_FILE)) {
+        await this.save(DEFAULT_CONFIG);
+        logger.info('Global config initialized', { path: G360_CONFIG_FILE });
+      }
+    } catch (error) {
+      logger.error('Failed to initialize global config', { error: error.message });
+      throw error;
+    }
+  },
+
+  /**
+   * Carga la configuración global
+   * @returns {Promise<GlobalConfig>} Configuración global cargada
+   * @example
+   * const config = await globalConfig.load();
+   * console.log('Default skill:', config.defaultSkill);
+   */
+  async load() {
+    try {
+      if (!fs.existsSync(G360_CONFIG_FILE)) {
+        await this.init();
+        return { ...DEFAULT_CONFIG };
+      }
+
+      const config = await fs.readJson(G360_CONFIG_FILE);
+      return { ...DEFAULT_CONFIG, ...config };
+    } catch (error) {
+      logger.error('Failed to load global config', { error: error.message });
+      return { ...DEFAULT_CONFIG };
+    }
+  },
+
+  /**
+   * Guarda la configuración global
+   * @param {GlobalConfig} config - Configuración a guardar
+   * @returns {Promise<void>}
+   * @example
+   * await globalConfig.save({ defaultSkill: 'moderno' });
+   */
+  async save(config) {
+    try {
+      await fs.ensureDir(G360_CONFIG_DIR);
+      await fs.writeJson(G360_CONFIG_FILE, config, { spaces: 2 });
+      logger.debug('Global config saved');
+    } catch (error) {
+      logger.error('Failed to save global config', { error: error.message });
+      throw error;
+    }
+  },
+
+  /**
+   * Obtiene un valor de configuración específico
+   * @param {string} key - Clave de configuración (notación de puntos)
+   * @param {*} defaultValue - Valor por defecto si no existe
+   * @returns {Promise<*>} Valor de configuración
+   * @example
+   * const skill = await globalConfig.get('defaultSkill');
+   * const theme = await globalConfig.get('preferences.theme', 'dark');
+   */
+  async get(key, defaultValue = undefined) {
+    const config = await this.load();
+    
+    const keys = key.split('.');
+    let value = config;
+    
+    for (const k of keys) {
+      if (value && typeof value === 'object' && k in value) {
+        value = value[k];
+      } else {
+        return defaultValue;
+      }
+    }
+    
+    return value;
+  },
+
+  /**
+   * Establece un valor de configuración específico
+   * @param {string} key - Clave de configuración (notación de puntos)
+   * @param {*} value - Valor a establecer
+   * @returns {Promise<void>}
+   * @example
+   * await globalConfig.set('defaultSkill', 'moderno');
+   * await globalConfig.set('preferences.theme', 'light');
+   */
+  async set(key, value) {
+    const config = await this.load();
+    
+    const keys = key.split('.');
+    let current = config;
+    
+    for (let i = 0; i < keys.length - 1; i++) {
+      const k = keys[i];
+      if (!current[k] || typeof current[k] !== 'object') {
+        current[k] = {};
+      }
+      current = current[k];
+    }
+    
+    current[keys[keys.length - 1]] = value;
+    await this.save(config);
+  },
+
+  /**
+   * Agrega un proyecto a la lista de proyectos recientes
+   * @param {string} projectPath - Ruta del proyecto
+   * @param {Object} metadata - Metadatos del proyecto
+   * @returns {Promise<void>}
+   * @example
+   * await globalConfig.addRecentProject('/my/project', {
+   *   template: 'web-pwa',
+   *   skill: 'corporativo-movil'
+   * });
+   */
+  async addRecentProject(projectPath, metadata = {}) {
+    const config = await this.load();
+    
+    // Eliminar el proyecto si ya existe
+    config.recentProjects = config.recentProjects.filter(
+      p => p.path !== projectPath
+    );
+    
+    // Agregar al inicio
+    config.recentProjects.unshift({
+      path: projectPath,
+      lastAccessed: new Date().toISOString(),
+      ...metadata
+    });
+    
+    // Mantener solo los últimos 10 proyectos
+    config.recentProjects = config.recentProjects.slice(0, 10);
+    
+    await this.save(config);
+    logger.debug('Project added to recent projects', { path: projectPath });
+  },
+
+  /**
+   * Obtiene la lista de proyectos recientes
+   * @returns {Promise<Array>} Lista de proyectos recientes
+   * @example
+   * const recent = await globalConfig.getRecentProjects();
+   * recent.forEach(project => console.log(project.path));
+   */
+  async getRecentProjects() {
+    const config = await this.load();
+    return config.recentProjects || [];
+  },
+
+  /**
+   * Limpia la configuración global
+   * @returns {Promise<void>}
+   * @example
+   * await globalConfig.clear();
+   */
+  async clear() {
+    try {
+      if (fs.existsSync(G360_CONFIG_FILE)) {
+        await fs.remove(G360_CONFIG_FILE);
+        logger.info('Global config cleared');
+      }
+    } catch (error) {
+      logger.error('Failed to clear global config', { error: error.message });
+      throw error;
+    }
+  },
+
+  /**
+   * Verifica si la configuración global existe
+   * @returns {boolean} true si existe, false en caso contrario
+   * @example
+   * if (await globalConfig.exists()) {
+   *   console.log('Config exists');
+   * }
+   */
+  async exists() {
+    return fs.existsSync(G360_CONFIG_FILE);
+  }
+};

package/src/lib/i18n.js

@@ -0,0 +1,238 @@
+/**
+ * @file i18n.js
+ * @description Sistema de internacionalización para G360-CLI
+ */
+
+/**
+ * Traducciones disponibles
+ * @type {Object.<string, Object.<string, string>>}
+ */
+const translations = {
+  es: {
+    // Comandos
+    'command.init.title': '🚀 Inicialización de Proyecto G360',
+    'command.init.project': 'Proyecto',
+    'command.init.template': 'Plantilla',
+    'command.init.skill': 'Skill',
+    'command.init.target': 'Destino',
+    'command.init.success': '✅ Proyecto creado exitosamente',
+    'command.init.portable': '📦 Versión portable habilitada',
+    'command.init.next_steps': 'Próximos pasos',
+    
+    'command.list.title': '📋 Assets G360',
+    'command.list.templates': '📁 Plantillas',
+    'command.list.components': '🧩 Componentes',
+    'command.list.skills': '⚡ Skills',
+    'command.list.snippets': '📝 Snippets',
+    'command.list.no_templates': 'No se encontraron plantillas',
+    'command.list.no_components': 'No se encontraron componentes',
+    'command.list.no_skills': 'No se encontraron skills',
+    'command.list.no_snippets': 'No se encontraron snippets',
+    
+    'command.set-skill.title': '🎨 Selector de Skill G360',
+    'command.set-skill.success': '✅ Skill configurado correctamente',
+    'command.set-skill.not_found': '❌ Skill no encontrado',
+    'command.set-skill.already_exists': '⚠️ El proyecto ya tiene un skill configurado',
+    'command.set-skill.use_force': 'Usa --force para sobrescribir',
+    
+    'command.audit.title': '🔍 Auditoría de Proyecto G360',
+    'command.audit.results': '📊 Resultados de Auditoría',
+    'command.audit.passed': 'Pasaron',
+    'command.audit.failed': 'Fallaron',
+    'command.audit.warnings': 'Advertencias',
+    'command.audit.issues': 'Issues Encontrados',
+    'command.audit.compliant': '✅ El proyecto es compliant con G360',
+    'command.audit.issues_found': '⚠️ Algunos issues necesitan atención',
+    
+    'command.health.title': '🏥 Verificación de Salud G360',
+    'command.health.status': 'Estado del Sistema',
+    'command.health.healthy': '✅ El sistema está saludable',
+    'command.health.failed': '❌ Algunos checks fallaron',
+    
+    'command.clean.title': '🧹 Limpieza de Proyecto G360',
+    'command.clean.preview': '📋 DRY RUN - No se eliminarán archivos',
+    'command.clean.success': '✅ Limpieza completada',
+    
+    // Errores
+    'error.templates_not_found': '❌ Plantillas no encontradas. Ejecuta: g360 update',
+    'error.template_not_found': '❌ Plantilla no encontrada',
+    'error.directory_exists': '❌ El directorio ya existe. Usa --force para sobrescribir',
+    'error.path_not_found': '❌ Ruta no encontrada',
+    'error.config_not_found': '❌ No se pudo cargar la configuración de skills',
+    
+    // General
+    'general.available': 'Disponibles',
+    'general.device': 'Dispositivo',
+    'general.description': 'Descripción',
+    'general.language': 'Lenguaje',
+    'general.loading': 'Cargando...',
+    'general.done': 'Completado',
+    'general.cancelled': 'Cancelado',
+    'general.error': 'Error',
+    'general.warning': 'Advertencia',
+    'general.info': 'Información',
+    'general.success': 'Éxito'
+  },
+  
+  en: {
+    // Commands
+    'command.init.title': '🚀 G360 Project Initialization',
+    'command.init.project': 'Project',
+    'command.init.template': 'Template',
+    'command.init.skill': 'Skill',
+    'command.init.target': 'Target',
+    'command.init.success': '✅ Project created successfully',
+    'command.init.portable': '📦 Portable version enabled',
+    'command.init.next_steps': 'Next steps',
+    
+    'command.list.title': '📋 G360 Assets',
+    'command.list.templates': '📁 Templates',
+    'command.list.components': '🧩 Components',
+    'command.list.skills': '⚡ Skills',
+    'command.list.snippets': '📝 Snippets',
+    'command.list.no_templates': 'No templates found',
+    'command.list.no_components': 'No components found',
+    'command.list.no_skills': 'No skills found',
+    'command.list.no_snippets': 'No snippets found',
+    
+    'command.set-skill.title': '🎨 G360 Skill Selector',
+    'command.set-skill.success': '✅ Skill configured successfully',
+    'command.set-skill.not_found': '❌ Skill not found',
+    'command.set-skill.already_exists': '⚠️ Project already has a skill configured',
+    'command.set-skill.use_force': 'Use --force to overwrite',
+    
+    'command.audit.title': '🔍 G360 Project Audit',
+    'command.audit.results': '📊 Audit Results',
+    'command.audit.passed': 'Passed',
+    'command.audit.failed': 'Failed',
+    'command.audit.warnings': 'Warnings',
+    'command.audit.issues': 'Issues Found',
+    'command.audit.compliant': '✅ Project is G360 compliant',
+    'command.audit.issues_found': '⚠️ Some issues need attention',
+    
+    'command.health.title': '🏥 G360 Health Check',
+    'command.health.status': 'System Status',
+    'command.health.healthy': '✅ System is healthy',
+    'command.health.failed': '❌ Some checks failed',
+    
+    'command.clean.title': '🧹 G360 Project Clean',
+    'command.clean.preview': '📋 DRY RUN - No files will be removed',
+    'command.clean.success': '✅ Cleanup completed',
+    
+    // Errors
+    'error.templates_not_found': '❌ Templates not found. Run: g360 update',
+    'error.template_not_found': '❌ Template not found',
+    'error.directory_exists': '❌ Directory already exists. Use --force to overwrite',
+    'error.path_not_found': '❌ Path not found',
+    'error.config_not_found': '❌ Could not load skills configuration',
+    
+    // General
+    'general.available': 'Available',
+    'general.device': 'Device',
+    'general.description': 'Description',
+    'general.language': 'Language',
+    'general.loading': 'Loading...',
+    'general.done': 'Done',
+    'general.cancelled': 'Cancelled',
+    'general.error': 'Error',
+    'general.warning': 'Warning',
+    'general.info': 'Info',
+    'general.success': 'Success'
+  }
+};
+
+/**
+ * Idioma actual
+ * @type {string}
+ */
+let currentLanguage = 'es';
+
+/**
+ * Módulo de internacionalización para G360-CLI
+ * @namespace i18n
+ */
+export const i18n = {
+  /**
+   * Establece el idioma actual
+   * @param {string} language - Código de idioma ('es' | 'en')
+   * @returns {void}
+   * @example
+   * i18n.setLanguage('en');
+   */
+  setLanguage(language) {
+    if (translations[language]) {
+      currentLanguage = language;
+    } else {
+      console.warn(`Language '${language}' not supported, using 'es'`);
+    }
+  },
+
+  /**
+   * Obtiene el idioma actual
+   * @returns {string} Código de idioma actual
+   * @example
+   * const lang = i18n.getLanguage();
+   */
+  getLanguage() {
+    return currentLanguage;
+  },
+
+  /**
+   * Traduce una clave de texto
+   * @param {string} key - Clave de traducción
+   * @param {Object} [params] - Parámetros para interpolación
+   * @returns {string} Texto traducido
+   * @example
+   * const text = i18n.t('command.init.success');
+   * const text = i18n.t('command.init.project', { name: 'my-project' });
+   */
+  t(key, params = {}) {
+    const lang = translations[currentLanguage] || translations.es;
+    let text = lang[key] || translations.es[key] || key;
+    
+    // Interpolación de parámetros
+    Object.keys(params).forEach(param => {
+      text = text.replace(`{${param}}`, params[param]);
+    });
+    
+    return text;
+  },
+
+  /**
+   * Verifica si una clave de traducción existe
+   * @param {string} key - Clave de traducción
+   * @returns {boolean} true si existe, false en caso contrario
+   * @example
+   * if (i18n.has('command.init.success')) {
+   *   console.log(i18n.t('command.init.success'));
+   * }
+   */
+  has(key) {
+    const lang = translations[currentLanguage] || translations.es;
+    return key in lang;
+  },
+
+  /**
+   * Obtiene todos los idiomas disponibles
+   * @returns {string[]} Lista de códigos de idioma
+   * @example
+   * const languages = i18n.getAvailableLanguages();
+   * console.log('Available languages:', languages);
+   */
+  getAvailableLanguages() {
+    return Object.keys(translations);
+  },
+
+  /**
+   * Obtiene las traducciones para un idioma específico
+   * @param {string} language - Código de idioma
+   * @returns {Object|null} Objeto de traducciones o null si no existe
+   * @example
+   * const esTranslations = i18n.getTranslations('es');
+   */
+  getTranslations(language) {
+    return translations[language] || null;
+  }
+};
+
+export default i18n;

package/src/lib/logger.js

@@ -0,0 +1,100 @@
+import winston from 'winston';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Niveles de log disponibles
+ * @enum {string}
+ */
+const LogLevel = {
+  ERROR: 'error',
+  WARN: 'warn',
+  INFO: 'info',
+  DEBUG: 'debug'
+};
+
+/**
+ * Formato personalizado para logs
+ * @param {Object} info - Información del log
+ * @returns {string} Log formateado
+ */
+const customFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+  winston.format.errors({ stack: true }),
+  winston.format.printf(({ level, message, timestamp, ...metadata }) => {
+    let msg = `${timestamp} [${level.toUpperCase()}]: ${message}`;
+    
+    if (Object.keys(metadata).length > 0) {
+      msg += ` ${JSON.stringify(metadata)}`;
+    }
+    
+    return msg;
+  })
+);
+
+/**
+ * Logger configurado para G360-CLI
+ * @type {winston.Logger}
+ */
+export const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: customFormat,
+  transports: [
+    // Console transport para desarrollo
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        customFormat
+      )
+    }),
+    
+    // File transport para logs persistentes
+    new winston.transports.File({
+      filename: path.join(__dirname, '../../logs/g360-cli.log'),
+      level: 'info',
+      maxsize: 5242880, // 5MB
+      maxFiles: 3
+    }),
+    
+    // Error file transport
+    new winston.transports.File({
+      filename: path.join(__dirname, '../../logs/error.log'),
+      level: 'error',
+      maxsize: 5242880, // 5MB
+      maxFiles: 3
+    })
+  ]
+});
+
+/**
+ * Crea un logger hijo con contexto específico
+ * @param {string} context - Contexto del logger
+ * @returns {winston.Logger} Logger hijo con contexto
+ */
+export function createChildLogger(context) {
+  return logger.child({ context });
+}
+
+/**
+ * Logger para comandos CLI
+ */
+export const commandLogger = createChildLogger('command');
+
+/**
+ * Logger para operaciones de archivos
+ */
+export const fileLogger = createChildLogger('file');
+
+/**
+ * Logger para validaciones
+ */
+export const validationLogger = createChildLogger('validation');
+
+/**
+ * Logger para auditoría
+ */
+export const auditLogger = createChildLogger('audit');
+
+export default logger;

package/src/lib/manifest.js

@@ -1,7 +1,42 @@
 import fs from 'fs-extra';
 import path from 'path';
 
+/**
+ * @typedef {Object} ProjectManifest
+ * @property {string} name - Nombre del proyecto
+ * @property {string} template - Plantilla utilizada
+ * @property {string} version - Versión del proyecto
+ * @property {string} createdAt - Fecha de creación en formato ISO
+ * @property {Asset[]} assets - Lista de assets del proyecto
+ */
+
+/**
+ * @typedef {Object} Asset
+ * @property {string} name - Nombre del asset
+ * @property {string} type - Tipo del asset
+ * @property {string} addedAt - Fecha de adición en formato ISO
+ */
+
+/**
+ * Módulo para gestión de manifiestos de proyectos G360
+ * @namespace manifest
+ */
 export const manifest = {
+  /**
+   * Inicializa un nuevo manifiesto de proyecto
+   * @param {string} projectDir - Directorio del proyecto
+   * @param {Object} data - Datos del proyecto
+   * @param {string} data.name - Nombre del proyecto
+   * @param {string} data.template - Plantilla utilizada
+   * @param {string} data.version - Versión del proyecto
+   * @returns {Promise<ProjectManifest>} Manifiesto creado
+   * @example
+   * const manifest = await manifest.init('/my/project', {
+   *   name: 'my-project',
+   *   template: 'web-pwa',
+   *   version: '1.0.0'
+   * });
+   */
   async init(projectDir, data) {
     const manifestPath = path.join(projectDir, 'g360-manifest.json');
     const manifest = {
@@ -15,14 +50,41 @@ export const manifest = {
     return manifest;
   },
 
+  /**
+   * Carga el manifiesto de un proyecto existente
+   * @param {string} projectDir - Directorio del proyecto
+   * @returns {Promise<ProjectManifest|null>} Manifiesto del proyecto o null si no existe
+   * @example
+   * const manifest = await manifest.load('/my/project');
+   * if (manifest) {
+   *   console.log('Proyecto:', manifest.name);
+   * }
+   */
   async load(projectDir) {
     const manifestPath = path.join(projectDir, 'g360-manifest.json');
     if (fs.existsSync(manifestPath)) {
-      return fs.readJson(manifestPath);
+      try {
+        return await fs.readJson(manifestPath);
+      } catch (error) {
+        return null;
+      }
     }
     return null;
   },
 
+  /**
+   * Agrega un asset al manifiesto del proyecto
+   * @param {string} projectDir - Directorio del proyecto
+   * @param {Object} asset - Asset a agregar
+   * @param {string} asset.name - Nombre del asset
+   * @param {string} asset.type - Tipo del asset
+   * @returns {Promise<void>}
+   * @example
+   * await manifest.addAsset('/my/project', {
+   *   name: 'components',
+   *   type: 'directory'
+   * });
+   */
   async addAsset(projectDir, asset) {
     const data = await this.load(projectDir);
     if (data) {
@@ -34,6 +96,13 @@ export const manifest = {
     }
   },
 
+  /**
+   * Elimina el manifiesto del proyecto
+   * @param {string} projectDir - Directorio del proyecto
+   * @returns {Promise<void>}
+   * @example
+   * await manifest.remove('/my/project');
+   */
   async remove(projectDir) {
     const manifestPath = path.join(projectDir, 'g360-manifest.json');
     if (fs.existsSync(manifestPath)) {