g360-cli 1.10.0 → 1.11.0

package/src/commands/set-skill.js

@@ -12,11 +12,13 @@ import { fileURLToPath } from 'url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const SKILLS_PATH = path.resolve(__dirname, '../assets/config/g360-skills.json');
 
-export async function setSkill(skillName, options) {
-  const { verbose = false, cwd = process.cwd() } = options;
+export async function setSkill(skillName, options = {}) {
+  const { verbose = false, cwd = process.cwd(), force = false } = options;
   const isInternalCall = options.cwd !== undefined;
   
-  console.log(chalk.bold.cyan('\n🎨 G360 Skill Selector\n'));
+  if (!isInternalCall) {
+    console.log(chalk.bold.cyan('\n🎨 G360 Skill Selector\n'));
+  }
   
   // Cargar skills disponibles
   let skillsConfig;
@@ -43,9 +45,9 @@ export async function setSkill(skillName, options) {
   const skillJsonPath = path.join(cwd, 'skill.json');
   
   if (fs.existsSync(skillJsonPath)) {
-    console.log(chalk.yellow('⚠️  El proyecto ya tiene un skill configurado.'));
-    console.log(chalk.gray('Usar --force para sobrescribir'));
-    if (!options.force) {
+    if (!force) {
+      console.log(chalk.yellow('⚠️  El proyecto ya tiene un skill configurado.'));
+      console.log(chalk.gray('Usar --force para sobrescribir'));
       console.log(chalk.cyan('\nPara cambiar el skill:'));
       console.log(chalk.cyan('  g360 set-skill ') + skillName + chalk.cyan(' --force'));
       return;
@@ -65,17 +67,19 @@ export async function setSkill(skillName, options) {
     
     await fs.writeJson(skillJsonPath, skillData, { spaces: 2 });
     
-    console.log(chalk.green(`\n✅ Skill "${skillName}" configurado correctamente`));
-    console.log(chalk.gray('\nDetalles:'));
-    console.log(`  Device: ${skill.device}`);
-    console.log(`  Accent: ${skill.colors.accent}`);
-    console.log(`  Signature: ${skill.signature.mode}`);
-    
-    if (verbose) {
-      console.log(chalk.gray('\nColores:'));
-      Object.entries(skill.colors).forEach(([key, value]) => {
-        console.log(`  ${key}: ${value}`);
-      });
+    if (!isInternalCall) {
+      console.log(chalk.green(`\n✅ Skill "${skillName}" configurado correctamente`));
+      console.log(chalk.gray('\nDetalles:'));
+      console.log(`  Device: ${skill.device}`);
+      console.log(`  Accent: ${skill.colors.accent}`);
+      console.log(`  Signature: ${skill.signature.mode}`);
+
+      if (verbose) {
+        console.log(chalk.gray('\nColores:'));
+        Object.entries(skill.colors).forEach(([key, value]) => {
+          console.log(`  ${key}: ${value}`);
+        });
+      }
     }
     
   } catch (error) {

package/src/commands/set-skill.test.js

@@ -0,0 +1,134 @@
+/**
+ * @file set-skill.test.js
+ * @description Tests para el comando set-skill
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { setSkill } from '../commands/set-skill.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Mock de fs-extra
+vi.mock('fs-extra', () => ({
+  default: {
+    existsSync: vi.fn(),
+    readJson: vi.fn(),
+    readJsonSync: vi.fn(),
+    writeJson: vi.fn()
+  }
+}));
+
+describe('set-skill command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Mockear console.log para evitar output en los tests
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('valid skill selection', () => {
+    it('should set skill successfully', async () => {
+      const mockSkills = {
+        skills: [
+          { name: 'corporativo', description: 'Proyectos corporativos', device: 'pc', colors: { accent: '#00796B' }, signature: { mode: 'powered' } }
+        ]
+      };
+
+      fs.readJson.mockResolvedValue(mockSkills);
+      fs.existsSync.mockReturnValue(false);
+      fs.writeJson.mockResolvedValue();
+
+      await setSkill('corporativo', { verbose: false, cwd: process.cwd() });
+
+      expect(fs.writeJson).toHaveBeenCalled();
+    });
+
+    it('should overwrite existing skill with --force', async () => {
+      const mockSkills = {
+        skills: [
+          { name: 'corporativo', description: 'Proyectos corporativos', device: 'pc', colors: { accent: '#00796B' }, signature: { mode: 'powered' } }
+        ]
+      };
+
+      fs.readJson.mockResolvedValue(mockSkills);
+      fs.existsSync.mockReturnValue(true);
+      fs.writeJson.mockResolvedValue();
+
+      await setSkill('corporativo', { verbose: false, force: true, cwd: process.cwd() });
+
+      expect(fs.writeJson).toHaveBeenCalled();
+    });
+  });
+
+  describe('invalid skill selection', () => {
+    it('should reject invalid skill name', async () => {
+      const mockSkills = {
+        skills: [
+          { name: 'corporativo', description: 'Proyectos corporativos', device: 'pc' }
+        ]
+      };
+
+      fs.readJson.mockResolvedValue(mockSkills);
+
+      await setSkill('invalid-skill', { verbose: false, cwd: process.cwd() });
+
+      expect(fs.writeJson).not.toHaveBeenCalled();
+    });
+
+    it('should handle missing skills config file', async () => {
+      fs.readJson.mockRejectedValue(new Error('File not found'));
+
+      await setSkill('corporativo', { verbose: false, cwd: process.cwd() });
+
+      expect(fs.writeJson).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('skill already exists', () => {
+    it('should not overwrite without --force', async () => {
+      const mockSkills = {
+        skills: [
+          { name: 'corporativo', description: 'Proyectos corporativos', device: 'pc', colors: { accent: '#00796B' }, signature: { mode: 'powered' } }
+        ]
+      };
+
+      fs.readJsonSync.mockReturnValue(mockSkills);
+      fs.existsSync.mockReturnValue(true);
+
+      await setSkill('corporativo', { verbose: false, force: false, cwd: process.cwd() });
+
+      expect(fs.writeJson).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('verbose output', () => {
+    it('should show detailed colors with --verbose', async () => {
+      const mockSkills = {
+        skills: [
+          { 
+            name: 'corporativo', 
+            description: 'Proyectos corporativos', 
+            device: 'pc',
+            colors: { bg: '#0b1220', surface: '#151e2e', accent: '#00796B', text: '#f0f4f8', muted: '#94a3b8' },
+            signature: { mode: 'powered' }
+          }
+        ]
+      };
+
+      fs.readJson.mockResolvedValue(mockSkills);
+      fs.existsSync.mockReturnValue(false);
+      fs.writeJson.mockResolvedValue();
+
+      await setSkill('corporativo', { verbose: true, cwd: process.cwd() });
+
+      expect(fs.writeJson).toHaveBeenCalled();
+    });
+  });
+});

package/src/commands/signature.js

@@ -1,11 +1,14 @@
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
+import inquirer from 'inquirer';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const SIGNATURE_ASSETS = path.join(__dirname, '..', 'assets', 'signature');
 
+const VALID_COMMANDS = ['install', 'positions'];
+
 const POSITIONS = {
   'bottom-right': 'position: fixed; bottom: 16px; right: 16px; z-index: 99999;',
   'bottom-left': 'position: fixed; bottom: 16px; left: 16px; z-index: 99999;',
@@ -22,6 +25,18 @@ const FLET_POSITIONS = {
 };
 
 export async function signature(command, options) {
+  // Validacion del comando
+  if (!VALID_COMMANDS.includes(command)) {
+    console.error(chalk.red(`❌ Comando invalido: "${command}"`));
+    console.log(chalk.gray('Comandos disponibles:'));
+    console.log(chalk.gray('  install   - Instalar g360-signature en un proyecto'));
+    console.log(chalk.gray('  positions - Mostrar posiciones disponibles'));
+    console.log(chalk.gray('\nEjemplo:'));
+    console.log(chalk.gray('  g360 signature install'));
+    console.log(chalk.gray('  g360 signature positions'));
+    return;
+  }
+
   const {
     path: targetPath = '.',
     force = false,
@@ -43,22 +58,45 @@ export async function signature(command, options) {
       return;
     }
 
-    // Modo interactivo: guiar al usuario
+    // Modo interactivo: guiar al usuario con inquirer
+    let resolvedPosition = position;
+    let resolvedMode = mode;
+
     if (interactive) {
-      const selectedPosition = await interactivePosition(projectType);
-      if (selectedPosition) {
-        options.position = selectedPosition;
-      }
+      const answers = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'mode',
+          message: 'Selecciona el modo de la firma:',
+          choices: [
+            { name: 'Powered by G360 (recomendado)', value: 'powered' },
+            { name: 'Own (G360 by ccusi)', value: 'own' },
+          ],
+          default: 'powered',
+        },
+        {
+          type: 'list',
+          name: 'position',
+          message: 'Selecciona la posicion de la firma:',
+          choices: projectType === 'flet'
+            ? Object.entries(FLET_POSITIONS).map(([key, desc]) => ({ name: `${key}: ${desc}`, value: key }))
+            : Object.entries(POSITIONS).map(([key, desc]) => ({ name: `${key}: ${desc}`, value: key })),
+          default: 'bottom-right',
+        },
+      ]);
+
+      resolvedMode = answers.mode;
+      resolvedPosition = answers.position;
     }
 
     if (projectType === 'flet') {
-      await installFlet(targetDir, { force, mode, version, position: options.position });
+      await installFlet(targetDir, { force, mode: resolvedMode, version, position: resolvedPosition });
     } else if (projectType === 'web') {
-      await installWeb(targetDir, { force, mode, version, position: options.position });
+      await installWeb(targetDir, { force, mode: resolvedMode, version, position: resolvedPosition });
     }
 
     console.log(chalk.green('\n✅ g360-signature instalado exitosamente!'));
-    showUsageTips(projectType, options.position);
+    showUsageTips(projectType, resolvedPosition);
   }
 
   if (command === 'positions') {
@@ -96,24 +134,6 @@ function showPositions() {
   console.log(chalk.gray('\nEjemplo: g360 signature install --position bottom-left\n'));
 }
 
-async function interactivePosition(projectType) {
-  console.log(chalk.bold.cyan('\n📍 Selecciona la posicion de la firma:\n'));
-
-  const options = projectType === 'flet'
-    ? Object.entries(FLET_POSITIONS)
-    : Object.entries(POSITIONS);
-
-  options.forEach(([key, value], index) => {
-    console.log(chalk.white(`  ${index + 1}. ${key.padEnd(18)} ${chalk.gray(value)}`));
-  });
-
-  console.log(chalk.gray('\n  Presiona Enter para usar la posicion por defecto (bottom-right)'));
-  console.log(chalk.gray('  O escribe el nombre de la posicion\n'));
-
-  // En modo no-interactivo, retornar default
-  return null;
-}
-
 function showUsageTips(projectType, position) {
   console.log(chalk.bold.cyan('\n💡 Tips de uso:\n'));
 

package/src/commands/update.js

@@ -19,10 +19,22 @@ export async function update(options) {
   if (check) {
     try {
       console.log(chalk.gray(`Current version: ${currentVersion}`));
-      console.log(chalk.gray('Check npm for latest version...'));
-      console.log(chalk.yellow('\nUse: npm install -g g360-cli@latest to update'));
+      console.log(chalk.gray('Checking npm for latest version...\n'));
+
+      const latestVersion = execSync('npm view g360-cli version', { encoding: 'utf8' }).trim();
+      
+      if (latestVersion === currentVersion) {
+        console.log(chalk.green(`✅ You have the latest version (${currentVersion})`));
+      } else {
+        console.log(chalk.yellow(`📦 Latest version: ${latestVersion}`));
+        console.log(chalk.yellow(`📦 Current version: ${currentVersion}`));
+        console.log(chalk.cyan('\nTo update:'));
+        console.log(chalk.gray('  npm install -g g360-cli@latest'));
+      }
     } catch (error) {
       console.error(chalk.red(`Error checking version: ${error.message}`));
+      console.log(chalk.gray('\nTry manually:'));
+      console.log(chalk.gray('  npm view g360-cli version'));
     }
     return;
   }

package/src/lib/asset-validator.test.js

@@ -0,0 +1,237 @@
+/**
+ * @file asset-validator.test.js
+ * @description Tests para el módulo asset-validator
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import { assetValidator } from '../lib/asset-validator.js';
+
+// Mock de fs-extra
+vi.mock('fs-extra', () => ({
+  default: {
+    existsSync: vi.fn(),
+    readJson: vi.fn()
+  }
+}));
+
+// Mock de logger
+vi.mock('../lib/logger.js', () => ({
+  logger: {
+    debug: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn()
+  }
+}));
+
+describe('asset-validator module', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    assetValidator.clearCache();
+  });
+
+  describe('validateSkills', () => {
+    it('should validate valid skills data', async () => {
+      const validSkills = {
+        skills: [
+          {
+            name: 'corporativo',
+            description: 'Test skill',
+            device: 'pc',
+            colors: {
+              bg: '#0b1220',
+              surface: '#1a2332',
+              accent: '#00796B',
+              text: '#f0f4f8',
+              muted: '#94a3b8'
+            },
+            signature: {
+              mode: 'powered',
+              text: 'powered by G360'
+            }
+          }
+        ]
+      };
+
+      fs.existsSync.mockReturnValue(true);
+      fs.readJson.mockResolvedValue({
+        type: 'object',
+        properties: {
+          skills: {
+            type: 'array',
+            items: {
+              type: 'object',
+              required: ['name', 'description', 'device', 'colors', 'signature'],
+              properties: {
+                name: { type: 'string' },
+                description: { type: 'string' },
+                device: { type: 'string', enum: ['pc', 'movil', 'both'] },
+                colors: { type: 'object' },
+                signature: { type: 'object' }
+              }
+            }
+          }
+        }
+      });
+
+      const result = await assetValidator.validateSkills(validSkills);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should reject invalid skills data', async () => {
+      const invalidSkills = {
+        skills: [
+          {
+            name: 'test',
+            // Missing required fields
+          }
+        ]
+      };
+
+      fs.existsSync.mockReturnValue(true);
+      fs.readJson.mockResolvedValue({
+        type: 'object',
+        properties: {
+          skills: {
+            type: 'array',
+            items: {
+              type: 'object',
+              required: ['name', 'description', 'device', 'colors', 'signature']
+            }
+          }
+        }
+      });
+
+      const result = await assetValidator.validateSkills(invalidSkills);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('validateSnippets', () => {
+    it('should validate valid snippets data', async () => {
+      const validSnippets = {
+        snippets: [
+          {
+            name: 'test-snippet',
+            description: 'A test snippet',
+            code: 'console.log("test")'
+          }
+        ]
+      };
+
+      fs.existsSync.mockReturnValue(true);
+      fs.readJson.mockResolvedValue({
+        type: 'object',
+        properties: {
+          snippets: {
+            type: 'array',
+            items: {
+              type: 'object',
+              required: ['name', 'description', 'code']
+            }
+          }
+        }
+      });
+
+      const result = await assetValidator.validateSnippets(validSnippets);
+
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('validateAsset', () => {
+    it('should validate individual skill asset', async () => {
+      const skill = {
+        name: 'test-skill',
+        description: 'Test',
+        device: 'pc',
+        colors: { accent: '#00d084' },
+        signature: { mode: 'powered' }
+      };
+
+      fs.existsSync.mockReturnValue(true);
+      fs.readJson.mockResolvedValue({
+        type: 'object',
+        properties: {
+          skills: {
+            type: 'array',
+            items: { type: 'object' }
+          }
+        }
+      });
+
+      const result = await assetValidator.validateAsset('skill', skill);
+
+      expect(result).toHaveProperty('valid');
+    });
+
+    it('should validate individual snippet asset', async () => {
+      const snippet = {
+        name: 'test',
+        description: 'Test',
+        code: 'test'
+      };
+
+      fs.existsSync.mockReturnValue(true);
+      fs.readJson.mockResolvedValue({
+        type: 'object',
+        properties: {
+          snippets: {
+            type: 'array',
+            items: { type: 'object' }
+          }
+        }
+      });
+
+      const result = await assetValidator.validateAsset('snippet', snippet);
+
+      expect(result).toHaveProperty('valid');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle missing schema file', async () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = await assetValidator.validate('non-existent', {});
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('should handle invalid schema', async () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readJson.mockResolvedValue({ invalid: 'schema' });
+
+      const result = await assetValidator.validate('invalid-schema', {});
+
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('cache management', () => {
+    it('should cache compiled schemas', async () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readJson.mockResolvedValue({
+        type: 'object',
+        properties: {}
+      });
+
+      await assetValidator.validate('test', {});
+      await assetValidator.validate('test', {});
+
+      // Schema should be cached, so readJson should only be called once
+      expect(fs.readJson).toHaveBeenCalledTimes(1);
+    });
+
+    it('should clear cache when requested', async () => {
+      assetValidator.clearCache();
+
+      expect(assetValidator.schemaCache.size).toBe(0);
+    });
+  });
+});