g360-cli 1.9.0 → 1.10.1

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

package/src/lib/manifest.test.js

@@ -0,0 +1,173 @@
+/**
+ * @file manifest.test.js
+ * @description Tests para el módulo manifest
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import { manifest } from '../lib/manifest.js';
+
+// Mock de fs-extra
+vi.mock('fs-extra', () => ({
+  default: {
+    writeJson: vi.fn(),
+    readJson: vi.fn(),
+    existsSync: vi.fn(),
+    remove: vi.fn()
+  }
+}));
+
+describe('manifest module', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('init', () => {
+    it('should create a new manifest file', async () => {
+      const projectData = {
+        name: 'test-project',
+        template: 'web-pwa',
+        version: '1.0.0'
+      };
+
+      fs.writeJson.mockResolvedValue();
+
+      const result = await manifest.init('/test/project', projectData);
+
+      expect(fs.writeJson).toHaveBeenCalledWith(
+        path.join('/test/project', 'g360-manifest.json'),
+        expect.objectContaining({
+          name: 'test-project',
+          template: 'web-pwa',
+          version: '1.0.0',
+          createdAt: expect.any(String),
+          assets: []
+        }),
+        { spaces: 2 }
+      );
+
+      expect(result).toMatchObject({
+        name: 'test-project',
+        template: 'web-pwa',
+        version: '1.0.0'
+      });
+    });
+
+    it('should include assets array in manifest', async () => {
+      const projectData = {
+        name: 'test-project',
+        template: 'web-pwa',
+        version: '1.0.0'
+      };
+
+      fs.writeJson.mockResolvedValue();
+
+      const result = await manifest.init('/test/project', projectData);
+
+      expect(result.assets).toEqual([]);
+    });
+  });
+
+  describe('load', () => {
+    it('should load existing manifest', async () => {
+      const mockManifest = {
+        name: 'test-project',
+        template: 'web-pwa',
+        version: '1.0.0',
+        createdAt: '2024-01-01T00:00:00.000Z',
+        assets: []
+      };
+
+      fs.existsSync.mockReturnValue(true);
+      fs.readJson.mockResolvedValue(mockManifest);
+
+      const result = await manifest.load('/test/project');
+
+      expect(result).toEqual(mockManifest);
+    });
+
+    it('should return null for non-existing manifest', async () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = await manifest.load('/test/project');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null when manifest file does not exist', async () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readJson.mockRejectedValue(new Error('File not found'));
+
+      const result = await manifest.load('/test/project');
+
+      // El código actual no maneja errores de readJson, así que debería lanzar el error
+      // Para este test, vamos a verificar que el error se maneja correctamente
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('addAsset', () => {
+    it('should add asset to existing manifest', async () => {
+      const existingManifest = {
+        name: 'test-project',
+        template: 'web-pwa',
+        version: '1.0.0',
+        assets: []
+      };
+
+      const newAsset = {
+        name: 'components',
+        type: 'directory'
+      };
+
+      fs.readJson.mockResolvedValue(existingManifest);
+      fs.writeJson.mockResolvedValue();
+
+      await manifest.addAsset('/test/project', newAsset);
+
+      expect(fs.writeJson).toHaveBeenCalledWith(
+        path.join('/test/project', 'g360-manifest.json'),
+        expect.objectContaining({
+          assets: expect.arrayContaining([
+            expect.objectContaining({
+              name: 'components',
+              type: 'directory',
+              addedAt: expect.any(String)
+            })
+          ])
+        }),
+        { spaces: 2 }
+      );
+    });
+
+    it('should not add asset when manifest does not exist', async () => {
+      fs.readJson.mockResolvedValue(null);
+
+      await manifest.addAsset('/test/project', { name: 'test' });
+
+      expect(fs.writeJson).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('remove', () => {
+    it('should remove manifest file', async () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.remove.mockResolvedValue();
+
+      await manifest.remove('/test/project');
+
+      expect(fs.remove).toHaveBeenCalledWith(
+        path.join('/test/project', 'g360-manifest.json')
+      );
+    });
+
+    it('should handle non-existing manifest gracefully', async () => {
+      fs.existsSync.mockReturnValue(false);
+
+      await manifest.remove('/test/project');
+
+      expect(fs.remove).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/lib/python_runner.js

@@ -13,7 +13,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 /**
  * Retorna la ruta al directorio src/g360_core del módulo Python.
  */
-export function getPythonModulePath(): string {
+export function getPythonModulePath() {
   // Ruta de desarrollo: py/src/g360_core relativo a este archivo
   const devPath = path.join(__dirname, '..', 'py', 'src');
   if (fs.existsSync(devPath)) {
@@ -39,7 +39,7 @@ export function getPythonModulePath(): string {
 /**
  * Genera código Python que configura sys.path correctamente.
  */
-export function wrapPythonCode(pyCode: string): string {
+export function wrapPythonCode(pyCode) {
   const modulePath = getPythonModulePath().replace(/\\/g, '\\\\');
 
   return `
@@ -58,7 +58,7 @@ ${pyCode}
 /**
  * Ejecuta código Python y retorna su salida.
  */
-export async function runPython(pyCode: string): Promise<{ stdout: string; stderr: string }> {
+export async function runPython(pyCode) {
   const fullCode = wrapPythonCode(pyCode);
   const pyExec = process.env.PYTHON || 'python3';
 
@@ -71,19 +71,19 @@ export async function runPython(pyCode: string): Promise<{ stdout: string; stder
   let stdout = '';
   let stderr = '';
 
-  await new Promise<void>((resolve, reject) => {
-    proc.stdout?.on('data', (data: Buffer) => { stdout += data.toString(); });
-    proc.stderr?.on('data', (data: Buffer) => { stderr += data.toString(); });
+  await new Promise((resolve, reject) => {
+    proc.stdout?.on('data', (data) => { stdout += data.toString(); });
+    proc.stderr?.on('data', (data) => { stderr += data.toString(); });
 
     proc.on('close', (code) => {
       if (code === 0) resolve();
       else reject(new Error(stderr || `Python código ${code}`));
     });
 
-    proc.on('error', (err: Error) => {
+    proc.on('error', (err) => {
       reject(new Error(`Python no disponible: ${err.message}`));
     });
   });
 
   return { stdout, stderr };
-}
+}

package/src/lib/validator.test.js

@@ -0,0 +1,115 @@
+/**
+ * @file validator.test.js
+ * @description Tests para el módulo validator
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import { validator } from '../lib/validator.js';
+
+// Mock de fs-extra
+vi.mock('fs-extra', () => ({
+  default: {
+    existsSync: vi.fn()
+  }
+}));
+
+describe('validator module', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('isValidProjectName', () => {
+    it('should accept valid project names', () => {
+      expect(validator.isValidProjectName('my-project')).toBe(true);
+      expect(validator.isValidProjectName('project123')).toBe(true);
+      expect(validator.isValidProjectName('my-project-123')).toBe(true);
+      expect(validator.isValidProjectName('123project')).toBe(true); // Empieza con número es válido según la regex actual
+    });
+
+    it('should reject invalid project names', () => {
+      expect(validator.isValidProjectName('My-Project')).toBe(false); // Mayúsculas
+      expect(validator.isValidProjectName('my_project')).toBe(false); // Guiones bajos
+      expect(validator.isValidProjectName('my project')).toBe(false); // Espacios
+      expect(validator.isValidProjectName('-project')).toBe(false); // Empieza con guion
+      expect(validator.isValidProjectName('')).toBe(false); // Vacío
+    });
+  });
+
+  describe('isValidPath', () => {
+    it('should return true for existing paths', () => {
+      fs.existsSync.mockReturnValue(true);
+      expect(validator.isValidPath('/existing/path')).toBe(true);
+    });
+
+    it('should return false for non-existing paths', () => {
+      fs.existsSync.mockReturnValue(false);
+      expect(validator.isValidPath('/non/existing/path')).toBe(false);
+    });
+
+    it('should handle errors gracefully', () => {
+      fs.existsSync.mockImplementation(() => {
+        throw new Error('Permission denied');
+      });
+      expect(validator.isValidPath('/error/path')).toBe(false);
+    });
+  });
+
+  describe('validateProject', () => {
+    it('should validate a valid G360 project', () => {
+      fs.existsSync.mockImplementation((path) => {
+        // El directorio del proyecto existe
+        if (path === '/valid/project') return true;
+        // El manifest y el directorio g360 existen
+        if (path.includes('g360-manifest.json') || path.includes('g360')) return true;
+        return false;
+      });
+
+      const result = validator.validateProject('/valid/project');
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it('should return errors for non-existing project', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = validator.validateProject('/non/existing');
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Project directory does not exist');
+    });
+
+    it('should return warnings for missing G360 files', () => {
+      fs.existsSync.mockImplementation((path) => {
+        // El directorio del proyecto existe
+        if (path === '/project/without/g360') return true;
+        // El manifest y el directorio g360 no existen
+        return false;
+      });
+
+      const result = validator.validateProject('/project/without/g360');
+
+      expect(result.valid).toBe(true);
+      expect(result.warnings).toContain('No g360-manifest.json found');
+      expect(result.warnings).toContain('No g360 directory found');
+    });
+
+    it('should handle partial G360 setup', () => {
+      fs.existsSync.mockImplementation((path) => {
+        // El directorio del proyecto existe
+        if (path === '/project/partial') return true;
+        // Solo el manifest existe
+        if (path.includes('g360-manifest.json')) return true;
+        // El directorio g360 no existe
+        return false;
+      });
+
+      const result = validator.validateProject('/project/partial');
+
+      expect(result.valid).toBe(true);
+      expect(result.warnings).toContain('No g360 directory found');
+    });
+  });
+});

package/src/assets/engine/g360-data-validator.js

@@ -1,44 +0,0 @@
-export function validate(data, rules) {
-  const results = {
-    valid: true,
-    errors: [],
-    warnings: []
-  };
-
-  for (const [field, rule] of Object.entries(rules)) {
-    const value = data[field];
-
-    if (rule.required && (value === undefined || value === null || value === '')) {
-      results.errors.push({ field, message: `${field} is required` });
-      results.valid = false;
-      continue;
-    }
-
-    if (rule.type && value !== undefined) {
-      const actualType = Array.isArray(value) ? 'array' : typeof value;
-      if (actualType !== rule.type) {
-        results.errors.push({ field, message: `${field} should be ${rule.type}` });
-        results.valid = false;
-      }
-    }
-
-    if (rule.min !== undefined && typeof value === 'number' && value < rule.min) {
-      results.errors.push({ field, message: `${field} must be >= ${rule.min}` });
-      results.valid = false;
-    }
-
-    if (rule.max !== undefined && typeof value === 'number' && value > rule.max) {
-      results.errors.push({ field, message: `${field} must be <= ${rule.max}` });
-      results.valid = false;
-    }
-
-    if (rule.pattern && typeof value === 'string' && !rule.pattern.test(value)) {
-      results.errors.push({ field, message: `${field} format is invalid` });
-      results.valid = false;
-    }
-  }
-
-  return results;
-}
-
-export default { validate };

package/src/assets/engine/g360-engine.js

@@ -1,12 +0,0 @@
-const G360 = {
-  name: 'G360 Ecosystem',
-  version: '1.0.0',
-  config: {
-    theme: 'cool-light',
-    primaryColor: '#3B82F6',
-    secondaryColor: '#10B981',
-    accentColor: '#8B5CF6'
-  }
-};
-
-export default G360;

package/src/assets/engine/g360-field-mapper.js

@@ -1,35 +0,0 @@
-export function mapField(sourceField, fieldMap) {
-  const mapping = fieldMap[sourceField];
-  if (!mapping) {
-    return {
-      success: false,
-      targetField: null,
-      message: `No mapping found for: ${sourceField}`
-    };
-  }
-  return {
-    success: true,
-    targetField: mapping.target,
-    transformations: mapping.transform || []
-  };
-}
-
-export function validateMapping(sourceData, fieldMap) {
-  const results = {
-    valid: true,
-    errors: [],
-    warnings: []
-  };
-
-  for (const sourceField of Object.keys(sourceData)) {
-    const mapping = mapField(sourceField, fieldMap);
-    if (!mapping.success) {
-      results.warnings.push(mapping.message);
-    }
-  }
-
-  results.valid = results.errors.length === 0;
-  return results;
-}
-
-export default { mapField, validateMapping };