g360-cli 1.9.0 → 1.10.1

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/commands/validate.js

@@ -4,88 +4,86 @@
  * Valida archivos ERP sin procesar completamente.
  */
 
-import { Command } from 'commander';
 import chalk from 'chalk';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
 import fs from 'fs-extra';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-export = (program: Command) => {
-  program
-    .command('validate')
-    .argument('<paths...>', 'Archivos o directorios a validar')
-    .option('-r, --recursive', 'Buscar recursivamente en directorios')
-    .action(async (paths, options) => {
-      console.log(chalk.blue('\n🔍 Validando archivos ERP\n'));
-
-      const filesToCheck: string[] = [];
-      for (const rawPath of paths) {
-        const p = path.resolve(rawPath);
-        try {
-          const stat = await fs.stat(p);
-          if (stat.isFile()) {
-            if (p.match(/\.(xls|xlsx|csv)$/i)) {
-              filesToCheck.push(p);
-            }
-          } else if (stat.isDirectory()) {
-            const pattern = options.recursive ? '**/*' : '*';
-            const extPattern = /\.(xls|xlsx|csv)$/i;
-            const entries = await fs.readdir(p, { withFileTypes: true });
-            for (const entry of entries) {
-              const fullPath = path.join(p, entry.name);
-              if (entry.isFile() && extPattern.test(entry.name)) {
-                filesToCheck.push(fullPath);
-              } else if (entry.isDirectory() && options.recursive) {
-                // Simplificado: escaneo recursivo básico
-                const sub = await fs.readdir(fullPath, { withFileTypes: true });
-                for (const subEntry of sub) {
-                  if (subEntry.isFile() && extPattern.test(subEntry.name)) {
-                    filesToCheck.push(path.join(fullPath, subEntry.name));
-                  }
-                }
+export async function validate(paths, options) {
+  const { recursive = false } = options;
+  
+  console.log(chalk.blue('\n🔍 Validando archivos ERP\n'));
+
+  const filesToCheck = [];
+  for (const rawPath of paths) {
+    const p = path.resolve(rawPath);
+    try {
+      const stat = await fs.stat(p);
+      if (stat.isFile()) {
+        if (/\.(xls|xlsx|csv)$/i.test(p)) {
+          filesToCheck.push(p);
+        }
+      } else if (stat.isDirectory()) {
+        const pattern = recursive ? '**/*' : '*';
+        const extPattern = /\.(xls|xlsx|csv)$/i;
+        const entries = await fs.readdir(p, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path.join(p, entry.name);
+          if (entry.isFile() && extPattern.test(entry.name)) {
+            filesToCheck.push(fullPath);
+          } else if (entry.isDirectory() && recursive) {
+            // Simplificado: escaneo recursivo básico
+            const sub = await fs.readdir(fullPath, { withFileTypes: true });
+            for (const subEntry of sub) {
+              if (subEntry.isFile() && extPattern.test(subEntry.name)) {
+                filesToCheck.push(path.join(fullPath, subEntry.name));
               }
             }
           }
-        } catch (err) {
-          console.warn(chalk.yellow(`  ⚠ No se pudo acceder a ${p}: ${err.message}`));
         }
       }
+    } catch (err) {
+      console.warn(chalk.yellow(`  ⚠ No se pudo acceder a ${p}: ${err.message}`));
+    }
+  }
 
-      if (filesToCheck.length === 0) {
-        console.warn(chalk.yellow('  No se encontraron archivos para validar'));
-        return;
-      }
+  if (filesToCheck.length === 0) {
+    console.warn(chalk.yellow('  No se encontraron archivos para validar'));
+    return;
+  }
 
-      const results: Array<{ path: string; valid: boolean; missing: string[] }> = [];
+  const results = [];
 
-      for (const file of filesToCheck) {
-        try {
-          const validation = await validateSingleFile(file);
-          results.push(validation);
-        } catch (err: any) {
-          results.push({ path: file, valid: false, missing: [`ERROR: ${err.message}`] });
-        }
-      }
+  for (const file of filesToCheck) {
+    try {
+      const validation = await validateSingleFile(file);
+      results.push(validation);
+    } catch (err) {
+      results.push({ path: file, valid: false, missing: [`ERROR: ${err.message}`] });
+    }
+  }
 
-      let validCount = 0;
-      for (const res of results) {
-        const status = res.valid ? chalk.green('✅') : chalk.red('❌');
-        const filename = path.basename(res.path);
-        console.log(`${status} ${filename} (${res.valid ? 'OK' : 'FALLÓ'})`);
-        if (!res.valid && res.missing.length > 0) {
-          console.log(chalk.gray(`   Faltan: ${res.missing.join(', ')}`));
-        }
-        if (res.valid) validCount++;
-      }
+  let validCount = 0;
+  for (const res of results) {
+    const status = res.valid ? chalk.green('✅') : chalk.red('❌');
+    const filename = path.basename(res.path);
+    console.log(`${status} ${filename} (${res.valid ? 'OK' : 'FALLÓ'})`);
+    if (!res.valid && res.missing.length > 0) {
+      console.log(chalk.gray(`   Faltan: ${res.missing.join(', ')}`));
+    }
+    if (res.valid) validCount++;
+  }
 
-      console.log(chalk.gray(`\n📊 Resumen: ${validCount}/${results.length} archivos válidos`));
-    });
-};
+  console.log(chalk.gray(`\n📊 Resumen: ${validCount}/${results.length} archivos válidos`));
+}
 
-async function validateSingleFile(filepath: string): Promise<{ path: string; valid: boolean; missing: string[] }> {
+async function validateSingleFile(filepath) {
   const pyCode = `
+import sys
+sys.path.insert(0, '${path.join(__dirname, '..', 'py', 'src')}')
 from g360_core.scanner import ERPScanner
 from pathlib import Path
 
@@ -102,12 +100,11 @@ except Exception as e:
 `;
 
   try {
-    const { runPython } = await import('../lib/python_runner.js');
     const result = await runPython(pyCode);
     const lines = result.stdout.split('\n').filter(l => l.trim());
 
     let valid = false;
-    let missing: string[] = [];
+    let missing = [];
 
     for (const line of lines) {
       if (line.startsWith('VALID=')) {
@@ -120,7 +117,34 @@ except Exception as e:
     }
 
     return { path: filepath, valid, missing };
-  } catch (err: any) {
+  } catch (err) {
     return { path: filepath, valid: false, missing: [err.message] };
   }
 }
+
+function runPython(code) {
+  return new Promise((resolve, reject) => {
+    const pyExec = process.env.PYTHON || 'python3';
+    const proc = spawn(pyExec, ['-c', code], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout?.on('data', (data) => { stdout += data.toString(); });
+    proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        reject(new Error(stderr || `Python terminó con código ${code}`));
+      }
+    });
+
+    proc.on('error', (err) => {
+      reject(new Error(`No se pudo ejecutar Python: ${err.message}`));
+    });
+  });
+}