g360-cli 1.3.0 → 1.5.0

package/src/lib/asset-validator.js

@@ -0,0 +1,145 @@
+import Ajv from 'ajv';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logger } from './logger.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * @typedef {Object} ValidationResult
+ * @property {boolean} valid - Indica si la validación fue exitosa
+ * @property {string[]} errors - Lista de errores encontrados
+ */
+
+/**
+ * Módulo de validación de assets con JSON Schema
+ * @namespace assetValidator
+ */
+export const assetValidator = {
+  /**
+   * Instancia de AJV para validación de schemas
+   * @type {Ajv}
+   */
+  ajv: new Ajv({ allErrors: true }),
+
+  /**
+   * Cache de schemas compilados
+   * @type {Map<string, any>}
+   */
+  schemaCache: new Map(),
+
+  /**
+   * Carga y compila un schema JSON
+   * @param {string} schemaName - Nombre del schema a cargar
+   * @returns {Promise<any>} Schema compilado
+   * @private
+   */
+  async loadSchema(schemaName) {
+    if (this.schemaCache.has(schemaName)) {
+      return this.schemaCache.get(schemaName);
+    }
+
+    const schemaPath = path.join(__dirname, '../schemas', `${schemaName}.json`);
+    
+    if (!fs.existsSync(schemaPath)) {
+      throw new Error(`Schema not found: ${schemaName}`);
+    }
+
+    const schema = await fs.readJson(schemaPath);
+    const compiled = this.ajv.compile(schema);
+    
+    this.schemaCache.set(schemaName, compiled);
+    return compiled;
+  },
+
+  /**
+   * Valida un objeto contra un schema específico
+   * @param {string} schemaName - Nombre del schema a usar
+   * @param {Object} data - Datos a validar
+   * @returns {Promise<ValidationResult>} Resultado de la validación
+   * @example
+   * const result = await assetValidator.validate('skills-schema', skillsData);
+   * if (result.valid) {
+   *   console.log('Skills válidos');
+   * } else {
+   *   console.error('Errores:', result.errors);
+   * }
+   */
+  async validate(schemaName, data) {
+    try {
+      const validate = await this.loadSchema(schemaName);
+      const valid = validate(data);
+
+      if (valid) {
+        logger.debug(`Validation passed for schema: ${schemaName}`);
+        return { valid: true, errors: [] };
+      }
+
+      const errors = validate.errors.map(err => 
+        `${err.instancePath} ${err.message}`
+      );
+
+      logger.warn(`Validation failed for schema: ${schemaName}`, { errors });
+      return { valid: false, errors };
+    } catch (error) {
+      logger.error(`Error validating against schema: ${schemaName}`, { error: error.message });
+      return { 
+        valid: false, 
+        errors: [`Validation error: ${error.message}`] 
+      };
+    }
+  },
+
+  /**
+   * Valida la configuración de skills
+   * @param {Object} skillsData - Datos de skills a validar
+   * @returns {Promise<ValidationResult>} Resultado de la validación
+   * @example
+   * const result = await assetValidator.validateSkills(skillsConfig);
+   */
+  async validateSkills(skillsData) {
+    return this.validate('skills-schema', skillsData);
+  },
+
+  /**
+   * Valida la configuración de snippets
+   * @param {Object} snippetsData - Datos de snippets a validar
+   * @returns {Promise<ValidationResult>} Resultado de la validación
+   * @example
+   * const result = await assetValidator.validateSnippets(snippetsConfig);
+   */
+  async validateSnippets(snippetsData) {
+    return this.validate('snippets-schema', snippetsData);
+  },
+
+  /**
+   * Valida un asset individual
+   * @param {string} assetType - Tipo de asset ('skill' | 'snippet')
+   * @param {Object} assetData - Datos del asset a validar
+   * @returns {Promise<ValidationResult>} Resultado de la validación
+   * @example
+   * const result = await assetValidator.validateAsset('skill', skillData);
+   */
+  async validateAsset(assetType, assetData) {
+    const schemaName = assetType === 'skill' ? 'skills-schema' : 'snippets-schema';
+    
+    // Para validación individual, envolvemos el asset en la estructura esperada
+    const wrapper = assetType === 'skill' 
+      ? { skills: [assetData] }
+      : { snippets: [assetData] };
+
+    const result = await this.validate(schemaName, wrapper);
+    
+    return result;
+  },
+
+  /**
+   * Limpia el cache de schemas
+   * @returns {void}
+   */
+  clearCache() {
+    this.schemaCache.clear();
+    logger.debug('Schema cache cleared');
+  }
+};

package/src/lib/auditor.js

@@ -2,7 +2,37 @@ import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
 
+/**
+ * @typedef {Object} AuditIssue
+ * @property {string} file - Archivo donde se encontró el issue
+ * @property {string} message - Mensaje descriptivo del issue
+ * @property {string} severity - Severidad del issue ('error' | 'warning')
+ */
+
+/**
+ * @typedef {Object} AuditResult
+ * @property {number} passed - Cantidad de checks que pasaron
+ * @property {number} failed - Cantidad de checks que fallaron
+ * @property {number} warnings - Cantidad de advertencias
+ * @property {number} total - Cantidad total de checks
+ * @property {AuditIssue[]} issues - Lista de issues encontrados
+ */
+
+/**
+ * Módulo de auditoría para proyectos G360
+ * @namespace auditor
+ */
 export const auditor = {
+  /**
+   * Ejecuta auditoría completa del proyecto
+   * @param {string} projectDir - Directorio del proyecto a auditar
+   * @param {Object} options - Opciones de auditoría
+   * @param {boolean} [options.verbose=false] - Mostrar información detallada
+   * @returns {Promise<AuditResult>} Resultado de la auditoría
+   * @example
+   * const result = await auditor.audit('/my/project', { verbose: true });
+   * console.log(`Passed: ${result.passed}, Failed: ${result.failed}`);
+   */
   async audit(projectDir, options = {}) {
     const { verbose = false } = options;
     const results = {
@@ -41,6 +71,12 @@ export const auditor = {
     return results;
   },
 
+  /**
+   * Verifica si existe el manifiesto del proyecto
+   * @param {string} projectDir - Directorio del proyecto
+   * @returns {Object} Resultado del check
+   * @private
+   */
   checkManifest(projectDir) {
     const manifestPath = path.join(projectDir, 'g360-manifest.json');
     if (fs.existsSync(manifestPath)) {
@@ -67,6 +103,12 @@ export const auditor = {
     return { status: 'warn', issue: { file: 'g360-manifest.json', message: 'No manifest found - run "g360 bring" to initialize' } };
   },
 
+  /**
+   * Verifica la estructura del proyecto
+   * @param {string} projectDir - Directorio del proyecto
+   * @returns {Object} Resultado del check
+   * @private
+   */
   checkStructure(projectDir) {
     const g360Dir = path.join(projectDir, 'g360');
     if (fs.existsSync(g360Dir)) {
@@ -94,6 +136,12 @@ export const auditor = {
     return { status: 'warn', issue: { file: 'g360/', message: 'No G360 assets found - run "g360 bring" to initialize assets' } };
   },
 
+  /**
+   * Verifica la configuración del proyecto
+   * @param {string} projectDir - Directorio del proyecto
+   * @returns {Object} Resultado del check
+   * @private
+   */
   checkConfig(projectDir) {
     const configPath = path.join(projectDir, 'g360', 'config');
     if (fs.existsSync(configPath)) {

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);
+  }
+};