g360-cli 1.7.1 → 1.10.0

package/src/commands/ingest.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * Comando: g360 ingest <archivo|directorio> [-o salida.csv]
+ * Procesa archivos ERP y genera maestro_ventas_crm.csv
+ */
+
+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 async function ingest(input, options) {
+  const { output = 'maestro_ventas_crm.csv' } = options;
+  
+  console.log(chalk.blue(`\n🚀 Iniciando ingesta: ${input}`));
+
+  const inputPath = path.resolve(input);
+  const outputPath = path.resolve(output);
+
+  // Determinar si es archivo o directorio
+  try {
+    await fs.access(inputPath);
+  } catch {
+    console.error(chalk.red(`❌ Ruta no encontrada: ${inputPath}`));
+    process.exit(1);
+  }
+
+  const stat = await fs.stat(inputPath);
+  let filepaths;
+
+  if (stat.isFile()) {
+    filepaths = [inputPath];
+  } else if (stat.isDirectory()) {
+    console.log(chalk.gray(`📁 Escaneando directorio...`));
+    const result = await scanDirectory(inputPath);
+    filepaths = result.valid.map(info => info.path);
+    if (filepaths.length === 0) {
+      console.error(chalk.red('❌ No se encontraron archivos ERP válidos en el directorio'));
+      process.exit(1);
+    }
+    console.log(chalk.green(`   Encontrados ${filepaths.length} archivos válidos`));
+  } else {
+    console.error(chalk.red(`❌ Ruta no válida: ${inputPath}`));
+    process.exit(1);
+  }
+
+  // Procesar archivos
+  console.log(chalk.blue(`\n⚙️  Procesando ${filepaths.length} archivo(s)...`));
+
+  try {
+    const combinedCsv = await runBatchIngest(filepaths);
+
+    // Escribir salida
+    await fs.ensureDir(path.dirname(outputPath));
+    await fs.writeFile(outputPath, combinedCsv, 'utf-8');
+    console.log(chalk.green(`\n✅ Ingesta completada: ${outputPath}`));
+
+    // Resumen por archivo
+    const lines = combinedCsv.split('\n');
+    const header = lines[0];
+    const dataLines = lines.filter(l => l && l !== header);
+    console.log(chalk.gray(`   Total filas: ${dataLines.length}`));
+
+    // Conteo por ARCHIVO_ORIGEN
+    const counts = new Map();
+    for (const line of dataLines) {
+      const cols = line.split(',');
+      const idx = header.split(',').indexOf('ARCHIVO_ORIGEN');
+      if (idx !== -1 && cols[idx]) {
+        counts.set(cols[idx], (counts.get(cols[idx]) || 0) + 1);
+      }
+    }
+    if (counts.size > 0) {
+      console.log(chalk.cyan('\n📊 Resumen por archivo:'));
+      for (const [file, count] of counts) {
+        console.log(`   ${file}: ${count} filas`);
+      }
+    }
+
+  } catch (err) {
+    console.error(chalk.red('\n❌ Error durante la ingesta:'), err.message);
+    if (err.stdout) console.error(chalk.gray(err.stdout));
+    if (err.stderr) console.error(chalk.red(err.stderr));
+    process.exit(1);
+  }
+}
+
+async function scanDirectory(dir) {
+  const pyCode = `
+import sys
+sys.path.insert(0, '${path.join(__dirname, '..', 'py', 'src')}')
+from g360_core.scanner import find_erp_files_in_dir
+from pathlib import Path
+
+valid, invalid = find_erp_files_in_dir(Path('${dir}'), recursive=True)
+for v in valid:
+    print(f"VALID::{v.path.name}::{v.erp_type}::${v.size_bytes}")
+for i in invalid[:10]:
+    print(f"INVALID::{i.path.name}::${i.error_msg}")
+`;
+
+  const result = await runPython(pyCode);
+  const lines = result.stdout.split('\n').filter(l => l.trim());
+  const valid = [];
+  const invalid = [];
+
+  for (const line of lines) {
+    if (line.startsWith('VALID::')) {
+      const [, name, type, size] = line.split('::');
+      valid.push({ path: path.join(dir, name), erp_type: type, size_bytes: parseInt(size) });
+    } else if (line.startsWith('INVALID::')) {
+      const [, name, error] = line.split('::');
+      invalid.push({ path: path.join(dir, name), error_msg: error });
+    }
+  }
+
+  return { valid, invalid };
+}
+
+async function runBatchIngest(filepaths) {
+  const pyCode = `
+import sys
+sys.path.insert(0, '${path.join(__dirname, '..', 'py', 'src')}')
+from g360_core.scanner import batch_process_files
+from pathlib import Path
+import pandas as pd
+
+filepaths = [${JSON.stringify(filepaths).replace(/"/g, "'")}]
+df = batch_process_files([Path(p) for p in filepaths], merge_results=True)
+sys.stdout.write(df.to_csv(index=False))
+`;
+
+  return new Promise((resolve, reject) => {
+    const pyExec = process.env.PYTHON || 'python3';
+    const proc = spawn(pyExec, ['-c', pyCode], {
+      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);
+      } 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}`));
+    });
+  });
+}
+
+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/commands/scan.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * Comando: g360 scan <directorio>
+ * Escanea un directorio para detectar archivos ERP válidos.
+ */
+
+import chalk from 'chalk';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function scan(directory, options) {
+  const { recursive = true, minScore = 10 } = options;
+  
+  console.log(chalk.blue(`\n🔍 Escaneando directorio: ${directory}`));
+
+  const pyCode = `
+import sys
+sys.path.insert(0, '${path.join(__dirname, '..', 'py', 'src')}')
+from g360_core.scanner import find_erp_files_in_dir
+from pathlib import Path
+import json
+
+valid, invalid = find_erp_files_in_dir(Path('${directory}'), recursive=${recursive})
+result = {
+    "valid": [{"path": str(v.path), "erp_type": v.erp_type, "size_bytes": v.size_bytes} for v in valid],
+    "invalid": [{"path": str(i.path), "error_msg": i.error_msg} for i in invalid],
+    "stats": {"total": len(valid) + len(invalid), "valid": len(valid), "invalid": len(invalid)}
+}
+print(json.dumps(result, indent=2))
+`;
+
+  try {
+    const result = await runPython(pyCode);
+    const data = JSON.parse(result.stdout);
+    
+    console.log(chalk.gray(`\n   Total archivos: ${data.stats.total}`));
+    console.log(chalk.green(`   Válidos: ${data.stats.valid}`));
+    console.log(chalk.red(`   Inválidos: ${data.stats.invalid}`));
+    
+    if (data.valid.length > 0) {
+      console.log(chalk.cyan('\n📋 Archivos válidos:'));
+      data.valid.forEach(f => {
+        console.log(chalk.gray(`   ${f.path} (${f.erp_type})`));
+      });
+    }
+    
+    if (data.invalid.length > 0) {
+      console.log(chalk.yellow('\n⚠️  Archivos inválidos:'));
+      data.invalid.forEach(f => {
+        console.log(chalk.red(`   ${f.path}: ${f.error_msg}`));
+      });
+    }
+    
+  } catch (err) {
+    console.error(chalk.red(`\n❌ Error escaneando: ${err.message}`));
+    if (err.stdout) console.log(chalk.gray(err.stdout));
+    if (err.stderr) console.error(chalk.red(err.stderr));
+    process.exit(1);
+  }
+}
+
+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/commands/validate.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * Comando: g360 validate <archivos/directorios>
+ * Valida archivos ERP sin procesar completamente.
+ */
+
+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 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}`));
+    }
+  }
+
+  if (filesToCheck.length === 0) {
+    console.warn(chalk.yellow('  No se encontraron archivos para validar'));
+    return;
+  }
+
+  const results = [];
+
+  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++;
+  }
+
+  console.log(chalk.gray(`\n📊 Resumen: ${validCount}/${results.length} archivos válidos`));
+}
+
+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
+
+scanner = ERPScanner(min_valid_score=10)
+try:
+    df = scanner._read_headers(Path('${filepath.replace(/'/g, "\\'")}'), nrows=50)
+    missing = scanner._validate_columns(df)
+    is_valid = len(missing) == 0
+    print(f"VALID={is_valid}")
+    if missing:
+        print(f"MISSING={','.join(missing)}")
+except Exception as e:
+    print(f"ERROR={str(e)}")
+`;
+
+  try {
+    const result = await runPython(pyCode);
+    const lines = result.stdout.split('\n').filter(l => l.trim());
+
+    let valid = false;
+    let missing = [];
+
+    for (const line of lines) {
+      if (line.startsWith('VALID=')) {
+        valid = line.split('=')[1] === 'True';
+      } else if (line.startsWith('MISSING=')) {
+        missing = line.split('=')[1].split(',');
+      } else if (line.startsWith('ERROR=')) {
+        throw new Error(line.split('=')[1]);
+      }
+    }
+
+    return { path: filepath, valid, missing };
+  } 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

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+/**
+ * Utilidad para obtener la ruta al módulo Python empaquetado.
+ * Funciona tanto en desarrollo como en ejecutables empaquetados con pkg.
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs-extra';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Retorna la ruta al directorio src/g360_core del módulo Python.
+ */
+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)) {
+    return devPath;
+  }
+
+  // En pkg (ejecutable empaquetado)
+  const basePath = process.execPath || process.argv[0];
+  const pkgPath = path.join(basePath, '..', 'resources', 'py', 'src');
+  if (fs.existsSync(pkgPath)) {
+    return pkgPath;
+  }
+
+  // Fallback: directorio actual
+  const cwdPath = path.join(process.cwd(), 'py', 'src');
+  if (fs.existsSync(cwdPath)) {
+    return cwdPath;
+  }
+
+  return devPath;
+}
+
+/**
+ * Genera código Python que configura sys.path correctamente.
+ */
+export function wrapPythonCode(pyCode) {
+  const modulePath = getPythonModulePath().replace(/\\/g, '\\\\');
+
+  return `
+import sys
+import os
+from pathlib import Path
+
+module_path = r"${modulePath}"
+if module_path not in sys.path:
+    sys.path.insert(0, module_path)
+
+${pyCode}
+`;
+}
+
+/**
+ * Ejecuta código Python y retorna su salida.
+ */
+export async function runPython(pyCode) {
+  const fullCode = wrapPythonCode(pyCode);
+  const pyExec = process.env.PYTHON || 'python3';
+
+  const { spawn } = await import('child_process');
+  const proc = spawn(pyExec, ['-c', fullCode], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
+  });
+
+  let stdout = '';
+  let stderr = '';
+
+  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) => {
+      reject(new Error(`Python no disponible: ${err.message}`));
+    });
+  });
+
+  return { stdout, stderr };
+}

package/py/src/g360_core/flet/__init__.py

@@ -1,3 +0,0 @@
-from g360_core.flet.ingestion_panel import IngestionPanel
-
-__all__ = ["IngestionPanel"]