g360-cli 1.9.0 → 1.10.0

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

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/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 };

package/src/assets/engine/g360-skill-audit.mjs

@@ -1,37 +0,0 @@
-export async function audit(code, options = {}) {
-  const results = {
-    score: 0,
-    issues: [],
-    suggestions: []
-  };
-
-  if (!code || code.length === 0) {
-    results.issues.push({ line: 0, message: 'Empty code' });
-    return results;
-  }
-
-  const lines = code.split('\n');
-  let score = 100;
-
-  lines.forEach((line, index) => {
-    if (line.length > 120) {
-      results.issues.push({ line: index + 1, message: 'Line too long (>120 chars)' });
-      score -= 2;
-    }
-    
-    if (line.includes('TODO') || line.includes('FIXME')) {
-      results.suggestions.push({ line: index + 1, message: 'Unresolved TODO/FIXME' });
-      score -= 1;
-    }
-  });
-
-  if (!code.includes('g360') && !code.includes('G360')) {
-    results.suggestions.push({ line: 0, message: 'Consider adding G360 identity' });
-    score -= 5;
-  }
-
-  results.score = Math.max(0, score);
-  return results;
-}
-
-export default { audit };

package/src/assets/engine/g360-skill-meta-evaluator.mjs

@@ -1,33 +0,0 @@
-export async function evaluateMetaTags(html) {
-  const results = {
-    score: 0,
-    tags: [],
-    issues: [],
-    suggestions: []
-  };
-
-  const requiredTags = ['title', 'description', 'viewport'];
-  const metaTags = html.match(/<meta[^>]+>/gi) || [];
-  
-  requiredTags.forEach(tag => {
-    if (html.includes(`name="${tag}"`) || html.includes(`property="${tag}"`)) {
-      results.tags.push({ tag, found: true });
-    } else {
-      results.issues.push({ tag, message: `Missing ${tag} tag` });
-    }
-  });
-
-  const ogTags = ['og:title', 'og:description', 'og:image'];
-  ogTags.forEach(tag => {
-    if (html.includes(`property="${tag}"`)) {
-      results.tags.push({ tag, found: true, type: 'og' });
-    } else {
-      results.suggestions.push({ tag, message: `Consider adding Open Graph: ${tag}` });
-    }
-  });
-
-  results.score = Math.round((results.tags.length / (requiredTags.length + ogTags.length)) * 100);
-  return results;
-}
-
-export default { evaluateMetaTags };

package/src/lib/assets.js

@@ -1,38 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export const assets = {
-  path: path.join(__dirname, '../assets'),
-
-  exists(assetPath) {
-    return fs.existsSync(path.join(this.path, assetPath));
-  },
-
-  async copy(assetPath, destPath, options = {}) {
-    const { overwrite = false } = options;
-    const src = path.join(this.path, assetPath);
-    const dest = path.join(destPath, path.basename(assetPath));
-
-    if (!this.exists(assetPath)) {
-      throw new Error(`Asset not found: ${assetPath}`);
-    }
-
-    if (fs.existsSync(dest) && !overwrite) {
-      throw new Error(`Destination already exists: ${dest}`);
-    }
-
-    await fs.copy(src, dest, { overwrite });
-    return dest;
-  },
-
-  list(category) {
-    const categoryPath = path.join(this.path, category);
-    if (!fs.existsSync(categoryPath)) {
-      return [];
-    }
-    return fs.readdirSync(categoryPath);
-  }
-};

package/src/lib/checksum.js

@@ -1,27 +0,0 @@
-import fs from 'fs-extra';
-import crypto from 'crypto';
-
-export const checksum = {
-  async calculate(filePath) {
-    const content = await fs.readFile(filePath);
-    return crypto.createHash('md5').update(content).digest('hex');
-  },
-
-  async verify(filePath, expectedHash) {
-    const actualHash = await this.calculate(filePath);
-    return actualHash === expectedHash;
-  },
-
-  async generateManifest(dir, files = []) {
-    const manifest = {};
-    
-    for (const file of files) {
-      const filePath = `${dir}/${file}`;
-      if (fs.existsSync(filePath)) {
-        manifest[file] = await this.calculate(filePath);
-      }
-    }
-    
-    return manifest;
-  }
-};

package/src/lib/config.js

@@ -1,23 +0,0 @@
-export const config = {
-  defaults: {
-    template: 'web-pwa',
-    assets: ['components', 'skills', 'engine'],
-    theme: 'cool-light'
-  },
-
-  projectTypes: {
-    'web-pwa': { framework: 'vanilla', features: ['pwa', 'offline'] },
-    'web-svelte': { framework: 'svelte', features: ['routing', 'stores'] },
-    'python-cli': { framework: 'python', features: ['cli', 'argparse'] },
-    'vba-excel': { framework: 'vba', features: ['excel', 'macros'] }
-  },
-
-  themes: {
-    'cool-light': { primary: '#3B82F6', secondary: '#10B981', accent: '#8B5CF6' },
-    'cool-dark': { primary: '#60A5FA', secondary: '#34D399', accent: '#A78BFA' },
-    'warm-light': { primary: '#F59E0B', secondary: '#EF4444', accent: '#8B5CF6' },
-    'warm-dark': { primary: '#FBBF24', secondary: '#F87171', accent: '#A78BFA' },
-    'neutral-light': { primary: '#6B7280', secondary: '#374151', accent: '#111827' },
-    'neutral-dark': { primary: '#9CA3AF', secondary: '#D1D5DB', accent: '#F9FAFB' }
-  }
-};

package/src/lib/offline.js

@@ -1,33 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-
-export const offline = {
-  cache: new Map(),
-  cacheDir: '.g360-cache',
-
-  async isAvailable() {
-    return true;
-  },
-
-  async getCached(asset) {
-    return this.cache.get(asset);
-  },
-
-  async setCache(asset, data) {
-    this.cache.set(asset, data);
-  },
-
-  async loadFromCache(asset) {
-    const cachePath = path.join(this.cacheDir, `${asset}.json`);
-    if (fs.existsSync(cachePath)) {
-      return fs.readJson(cachePath);
-    }
-    return null;
-  },
-
-  async saveToCache(asset, data) {
-    const cachePath = path.join(this.cacheDir, `${asset}.json`);
-    await fs.ensureDir(this.cacheDir);
-    await fs.writeJson(cachePath, data);
-  }
-};

package/src/lib/presenter.js

@@ -1,24 +0,0 @@
-import chalk from 'chalk';
-
-export const presenter = {
-  formatTree(items, prefix = '', isLast = true) {
-    return items.map((item, index) => {
-      const isLastItem = index === items.length - 1;
-      const connector = isLastItem ? '└── ' : '├── ';
-      return `${prefix}${connector}${item}`;
-    }).join('\n');
-  },
-
-  formatList(items, columns = 2) {
-    const rows = [];
-    for (let i = 0; i < items.length; i += columns) {
-      const row = items.slice(i, i + columns);
-      rows.push(row.join('\t'));
-    }
-    return rows.join('\n');
-  },
-
-  formatJson(data) {
-    return JSON.stringify(data, null, 2);
-  }
-};

package/src/lib/rollback.js

@@ -1,49 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-
-export const rollback = {
-  history: new Map(),
-
-  async snapshot(projectDir, label) {
-    const snapshot = {
-      timestamp: new Date().toISOString(),
-      label,
-      files: []
-    };
-
-    const g360Dir = path.join(projectDir, 'g360');
-    if (fs.existsSync(g360Dir)) {
-      const files = fs.readdirSync(g360Dir, { recursive: true, withFileTypes: true });
-      snapshot.files = files.map(f => ({
-        path: f.fullPath || path.join(g360Dir, f.name),
-        type: f.isDirectory() ? 'dir' : 'file'
-      }));
-    }
-
-    this.history.set(projectDir, snapshot);
-    return snapshot;
-  },
-
-  async restore(projectDir) {
-    const snapshot = this.history.get(projectDir);
-    if (!snapshot) {
-      throw new Error('No snapshot found for this project');
-    }
-
-    const g360Dir = path.join(projectDir, 'g360');
-    
-    if (fs.existsSync(g360Dir)) {
-      await fs.remove(g360Dir);
-    }
-
-    for (const file of snapshot.files) {
-      if (file.type === 'dir') {
-        await fs.ensureDir(file.path);
-      } else {
-        await fs.ensureFile(file.path);
-      }
-    }
-
-    return snapshot;
-  }
-};

package/src/lib/theme.js

@@ -1,30 +0,0 @@
-import chalk from 'chalk';
-
-export const theme = {
-  colors: {
-    primary: '#3B82F6',
-    secondary: '#10B981',
-    accent: '#8B5CF6',
-    success: '#22C55E',
-    warning: '#F59E0B',
-    error: '#EF4444',
-    info: '#06B6D4'
-  },
-
-  styles: {
-    header: chalk.bold.cyan,
-    success: chalk.green,
-    error: chalk.red,
-    warning: chalk.yellow,
-    info: chalk.blue,
-    muted: chalk.gray
-  },
-
-  format: {
-    title: (text) => chalk.bold.cyan(`\n${text}\n`),
-    section: (text) => chalk.bold.yellow(text),
-    item: (text) => chalk.white(text),
-    key: (text) => chalk.cyan(text),
-    value: (text) => chalk.white(text)
-  }
-};