g360-cli 1.7.1 → 1.9.0

package/src/commands/scan.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Comando: g360 scan <directorio>
+ * Escanea un directorio para detectar archivos ERP válidos.
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export = (program: Command) => {
+  program
+    .command('scan')
+    .argument('<directorio>', 'Directorio a escanear')
+    .option('-r, --recursive', 'Buscar recursivamente', true)
+    .option('--min-score <n>', 'Puntuación mínima', '10')
+    .action(async (directorio, options) => {
+      console.log(chalk.blue(`\n🔍 Escaneando directorio: ${directorio}`));
+
+      const pyCode = `
+import sys
+from pathlib import Path
+
+from g360_core.scanner import ERPScanner
+
+scanner = ERPScanner(min_valid_score=${options.minScore})
+files = scanner.scan_directory(Path('${directorio}'), recursive=${options.recursive})
+valid = scanner.get_valid_files(files)
+invalid = scanner.get_invalid_files(files)
+
+print(f"TOTAL={len(files)}")
+print(f"VALIDOS={len(valid)}")
+print(f"INVALIDOS={len(invalid)}")
+
+for erp_type, flist in scanner.group_by_erp_type(files).items():
+    if erp_type not in ('UNKNOWN', 'ERROR'):
+        print(f"TIPO::{erp_type}::{len(flist)}")
+        for info in flist[:5]:
+            print(f"FILE::{info.path.name}::{info.size_bytes}")
+
+for info in invalid[:10]:
+    print(f"INVALID::{info.path.name}::${info.error_msg}")
+`;
+
+      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 total = 0, validCount = 0, invalidCount = 0;
+        const types = new Map();
+
+        for (const line of lines) {
+          if (line.startsWith('TOTAL=')) total = parseInt(line.split('=')[1]);
+          else if (line.startsWith('VALIDOS=')) validCount = parseInt(line.split('=')[1]);
+          else if (line.startsWith('INVALIDOS=')) invalidCount = parseInt(line.split('=')[1]);
+          else if (line.startsWith('TIPO::')) {
+            const [, tipo, count] = line.split('::');
+            types.set(tipo, parseInt(count));
+          }
+        }
+
+        console.log(chalk.gray(`\n📈 Resultados:`));
+        console.log(`   Total archivos: ${total}`);
+        console.log(chalk.green(`   Válidos: ${validCount}`));
+        console.log(chalk.red(`   Inválidos/Error: ${invalidCount}`));
+
+        if (types.size > 0) {
+          console.log(chalk.green('\n✅ Archivos válidos por tipo ERP:'));
+          for (const [tipo, count] of types) {
+            console.log(`  ${tipo}: ${count} archivos`);
+          }
+        }
+
+        if (invalidCount > 0) {
+          console.log(chalk.red('\n❌ Archivos con problemas:'));
+          let invalidLines = lines.filter(l => l.startsWith('INVALID::'));
+          for (const line of invalidLines.slice(0, 10)) {
+            const parts = line.split('::');
+            console.log(`  • ${parts[1]}: ${parts.slice(2).join('::')}`);
+          }
+          if (invalidLines.length > 10) {
+            console.log(`  ... y ${invalidLines.length - 10} más`);
+          }
+        }
+
+        if (validCount > 0) {
+          console.log(chalk.cyan('\n💡 Para procesar todos estos archivos:'));
+          console.log(`   g360 ingest "${directorio}" -o maestro_ventas_crm.csv`);
+        }
+
+      } catch (err: any) {
+        console.error(chalk.red('❌ Error durante escaneo:'), err.message);
+        if (err.stdout) console.error(chalk.gray(err.stdout));
+        if (err.stderr) console.error(chalk.red(err.stderr));
+        process.exit(1);
+      }
+    });
+};

package/src/commands/validate.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Comando: g360 validate <archivos/directorios>
+ * Valida archivos ERP sin procesar completamente.
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import path from 'path';
+import { fileURLToPath } from 'url';
+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));
+                  }
+                }
+              }
+            }
+          }
+        } 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: Array<{ path: string; valid: boolean; missing: string[] }> = [];
+
+      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}`] });
+        }
+      }
+
+      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: string): Promise<{ path: string; valid: boolean; missing: string[] }> {
+  const pyCode = `
+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 { 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[] = [];
+
+    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: any) {
+    return { path: filepath, valid: false, missing: [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(): string {
+  // 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: string): string {
+  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: string): Promise<{ stdout: string; stderr: string }> {
+  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<void>((resolve, reject) => {
+    proc.stdout?.on('data', (data: Buffer) => { stdout += data.toString(); });
+    proc.stderr?.on('data', (data: Buffer) => { 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) => {
+      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"]

package/py/src/g360_core/flet/ingestion_panel.py

@@ -1,218 +0,0 @@
-import threading
-from pathlib import Path
-
-import flet as ft
-import pandas as pd
-
-from g360_core.ingestion import estabilizar_excel_crudo
-
-
-class IngestionPanel(ft.Container):
-    def __init__(self, theme, on_data_loaded=None):
-        super().__init__()
-        self.theme = theme
-        self.on_data_loaded = on_data_loaded
-        self.df: pd.DataFrame | None = None
-        self.metadata: dict | None = None
-        self._build()
-
-    def _build(self):
-        self.file_picker = ft.FilePicker(on_result=self._on_file_result)
-        self.status_text = ft.Text(
-            "Selecciona un archivo .xls o .xlsx del ERP",
-            size=14,
-            color=self.theme.muted,
-        )
-        self.stats_container = ft.Column(spacing=4, visible=False)
-        self.alertas_container = ft.Column(spacing=2, visible=False)
-        self.preview_table = ft.Column(scroll=ft.ScrollMode.AUTO, visible=False)
-
-        self.content = ft.Column(
-            controls=[
-                self.file_picker,
-                ft.Row(
-                    controls=[
-                        self.theme.accent_button(
-                            text="Cargar Archivo Excel",
-                            on_click=self._open_picker,
-                        ),
-                        ft.Container(width=12),
-                        self.status_text,
-                    ],
-                    alignment=ft.MainAxisAlignment.START,
-                    vertical_alignment=ft.CrossAxisAlignment.CENTER,
-                ),
-                ft.Container(height=12),
-                self.stats_container,
-                ft.Container(height=8),
-                self.alertas_container,
-                ft.Container(height=8),
-                self.preview_table,
-            ],
-            spacing=0,
-        )
-        self.bgcolor = self.theme.surface
-        self.border_radius = self.theme.rounded
-        self.padding = 20
-        self.expand = True
-
-    def _open_picker(self, e):
-        self.file_picker.pick_files(
-            file_type=ft.FilePickerFileType.CUSTOM,
-            allowed_extensions=["xls", "xlsx", "xlsm"],
-            dialog_title="Seleccionar reporte del ERP",
-        )
-
-    def _on_file_result(self, e: ft.FilePickerResultEvent):
-        if not e.files:
-            self.status_text.value = "No se selecciono ningun archivo."
-            self.status_text.color = self.theme.warning
-            self.update()
-            return
-
-        archivo = e.files[0]
-        ruta = archivo.path
-        nombre = archivo.name
-        self.status_text.value = f"Procesando: {nombre}..."
-        self.status_text.color = self.theme.text
-        self.update()
-
-        self._show_loading(True)
-
-        def _procesar():
-            try:
-                df, metadata = estabilizar_excel_crudo(ruta)
-                self.df = df
-                self.metadata = metadata
-                self._mostrar_resultado(df, metadata, nombre)
-                if self.on_data_loaded:
-                    self.on_data_loaded(df, metadata)
-            except Exception as exc:
-                self.status_text.value = f"Error: {exc}"
-                self.status_text.color = self.theme.error
-                self._show_loading(False)
-                self.update()
-
-        thread = threading.Thread(target=_procesar, daemon=True)
-        thread.start()
-
-    def _show_loading(self, visible: bool):
-        pass
-
-    def _mostrar_resultado(self, df: pd.DataFrame, metadata: dict, nombre: str):
-        self.status_text.value = f"OK: {nombre} ({len(df):,} filas)"
-        self.status_text.color = self.theme.success
-
-        columnas = metadata.get("columnas_finales", metadata.get("columnas", []))
-        transformaciones = metadata.get("transformaciones", [])
-        alertas = metadata.get("alertas", [])
-        columnas_nuevas = metadata.get("columnas_nuevas", [])
-
-        self.stats_container.controls = [
-            ft.Text("Resumen de Ingesta", size=16, weight=ft.FontWeight.BOLD, color=self.theme.text),
-            ft.Text(f"Filas estabilizadas: {len(df):,}", size=13, color=self.theme.muted),
-            ft.Text(f"Columnas originales: {metadata.get('filas_originales', 0)}", size=13, color=self.theme.muted),
-            ft.Text(f"Columnas finales: {len(columnas)}", size=13, color=self.theme.muted),
-            ft.Text(f"Archivo: {metadata.get('archivo', 'N/A')}", size=13, color=self.theme.muted),
-            ft.Text(f"Moneda: {metadata.get('moneda', 'N/A')}", size=13, color=self.theme.muted),
-            ft.Divider(color=self.theme.bg, height=8),
-        ]
-
-        if columnas_nuevas:
-            nuevas_text = ft.Text(
-                "Columnas derivadas:",
-                size=13, weight=ft.FontWeight.BOLD, color=self.theme.accent,
-            )
-            chips = ft.Row(
-                controls=[
-                    ft.Container(
-                        content=ft.Text(col, size=10, color=self.theme.bg),
-                        bgcolor=self.theme.accent,
-                        border_radius=12,
-                        padding=ft.padding.only(left=8, right=8, top=3, bottom=3),
-                    )
-                    for col in columnas_nuevas
-                ],
-                spacing=6,
-                wrap=True,
-            )
-            self.stats_container.controls.extend([nuevas_text, chips])
-
-        if transformaciones:
-            self.stats_container.controls.append(
-                ft.Divider(color=self.theme.bg, height=8)
-            )
-            self.stats_container.controls.append(
-                ft.Text("Transformaciones:", size=13, weight=ft.FontWeight.BOLD, color=self.theme.text)
-            )
-            for t in transformaciones[-8:]:
-                self.stats_container.controls.append(
-                    ft.Row(
-                        controls=[
-                            ft.Container(
-                                content=ft.Text(">", size=11, color=self.theme.accent),
-                                width=16,
-                            ),
-                            ft.Text(t, size=11, color=self.theme.muted),
-                        ],
-                        spacing=0,
-                    )
-                )
-
-        self.stats_container.visible = True
-
-        if alertas:
-            self.alertas_container.controls = [
-                ft.Divider(color=self.theme.bg, height=4),
-                ft.Text("Alertas:", size=13, weight=ft.FontWeight.BOLD, color=self.theme.warning),
-            ]
-            for a in alertas:
-                self.alertas_container.controls.append(
-                    ft.Row(
-                        controls=[
-                            ft.Icon(ft.icons.WARNING_AMBER_ROUNDED, size=14, color=self.theme.warning),
-                            ft.Text(a, size=11, color=self.theme.warning),
-                        ],
-                        spacing=4,
-                    )
-                )
-            self.alertas_container.visible = True
-
-        filas_preview = df.head(5)
-        columnas_preview = columnas[:8]
-
-        data_rows = []
-        for _, row in filas_preview.iterrows():
-            cells = []
-            for col in columnas_preview:
-                val = row.get(col, "")
-                v_str = str(val)[:30] if not pd.isna(val) else "-"
-                cells.append(
-                    ft.DataCell(ft.Text(v_str, size=10, color=self.theme.text))
-                )
-            data_rows.append(ft.DataRow(cells=cells))
-
-        header_cells = [
-            ft.DataColumn(ft.Text(col[:16], size=10, color=self.theme.accent, weight=ft.FontWeight.BOLD))
-            for col in columnas_preview
-        ]
-
-        tabla = ft.DataTable(
-            columns=header_cells,
-            rows=data_rows,
-            heading_text_color=self.theme.accent,
-            horizontal_margin=4,
-            column_spacing=16,
-        )
-
-        self.preview_table.controls = [
-            ft.Text("Vista previa (5 primeras filas):", size=13, weight=ft.FontWeight.BOLD, color=self.theme.text),
-            ft.Container(
-                content=tabla,
-                bgcolor=self.theme.bg,
-                border_radius=8,
-                padding=8,
-            ),
-        ]
-        self.preview_table.visible = True
-        self.update()