g360-cli 1.9.0 → 1.10.0

package/README.md

@@ -854,7 +854,7 @@ g360-cli/
 |---------|-------------|
 | `npm run build` | Build portable con pkg (g360.exe) |
 | `npm run build:portable` | Especificar target node18-win-x64 |
-| `npm test` | Ejecutar tests con Vitest (51 tests, 7 suites) |
+ | `npm test` | Ejecutar tests con Vitest (53 tests, 9 suites) |
 | `npm run prepublishOnly` | Validación antes de publicar en npm |
 
 ---
@@ -862,16 +862,16 @@ g360-cli/
 ## Testing
 
 ```bash
-npm test            # Vitest — 51 tests, 8 suites
+npm test            # Vitest — 53 tests, 9 suites
 npm run test:watch  # Modo watch
 npm run test:ui     # UI interactiva
 npm run test:coverage
 ```
 
-**Cobertura actual (v1.9.0):**
-- `commands/`: init, bring, list, audit, set-skill
-- `lib/`: manifest, validator, asset-validator
-- **51 passing / 1 timeout** (init.test.js requiere import pesado de inquirer)
+**Cobertura actual (v1.10.0):**
+- `commands/`: init, bring, list, audit, set-skill, addon
+- `lib/`: manifest, validator, asset-validator, python_runner
+- **53 passing / 1 timeout** (init.test.js requiere import pesado de inquirer)
 
 ---
 
@@ -911,6 +911,47 @@ Este proyecto forma parte de la familia de microherramientas **G360** para apoyo
 
 ---
 
+### `g360 addon`
+
+Gestión de addons y paquetes de desarrollo.
+
+```bash
+g360 addon <comando> [paquete] [opciones]
+```
+
+**Comandos:**
+- `install <package>` - Instala un addon (core o dev-tool)
+- `list` - Lista addons instalados
+- `remove <package>` - Desinstala un addon
+
+**Opciones:**
+| Opción | Descripción |
+|--------|-------------|
+| `-p, --path <ruta>` | Ruta destino (default: `.`) |
+| `--dry-run` | Previsualizar cambios |
+| `--force` | Forzar reinstalación/remoción |
+
+**Ejemplos:**
+```bash
+# Instalar paquete de diseño (core)
+g360 addon install @google/design.md
+
+# Instalar kit de testing (dev)
+g360 addon install @g360/testing
+
+# Listar addons
+g360 addon list
+
+# Remover addon
+g360 addon remove @google/design.md
+```
+
+**Registro de addons:**
+- 🏛️ Core Dev: Van a `dependencies` (producción)
+- 🛠️ Dev Tools: Van a `devDependencies` (desarrollo)
+
+---
+
 ## Integración con OpenCode
 
 g360-cli incluye integración con **OpenCode** para desarrollo asistido por IA. Esta integración permite que los agentes de IA tengan acceso a los recursos de g360-cli durante el desarrollo.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "g360-cli",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "CLI tool for bootstrapping G360 projects with standardized structure, assets, identity, and ERP data processing",
   "type": "module",
   "main": "src/cli.js",

package/src/cli.js

@@ -19,6 +19,7 @@ import { signature } from './commands/signature.js';
 import { scan } from './commands/scan.js';
 import { validate } from './commands/validate.js';
 import { ingest } from './commands/ingest.js';
+import { addon } from './commands/addon.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = fs.readJsonSync(path.join(__dirname, '../package.json'));
@@ -142,4 +143,13 @@ program
   .option('-o, --output <archivo>', 'Ruta de salida', 'maestro_ventas_crm.csv')
   .action(ingest);
 
+program
+  .command('addon')
+  .argument('<command>', 'Command: install, list, remove')
+  .argument('[package]', 'Package name to install')
+  .option('-p, --path <path>', 'Target path', '.')
+  .option('--dry-run', 'Preview without installing')
+  .option('--force', 'Force reinstall/remove')
+  .action(addon);
+
 program.parse();

package/src/commands/addon.js

@@ -0,0 +1,188 @@
+import chalk from 'chalk';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const ADDON_REGISTRY = {
+  '@google/design.md': {
+    name: 'Google Design System',
+    type: 'design-system',
+    install: async (targetDir) => {
+      const addonDir = path.join(targetDir, 'g360', 'addons', 'google-design');
+      fs.mkdirpSync(addonDir);
+      
+      const indexContent = {
+        name: 'google-design',
+        source: '@google/design.md',
+        installedAt: new Date().toISOString(),
+        files: [
+          'tokens.json',
+          'components.css',
+          'md3.css'
+        ]
+      };
+      
+      fs.writeJsonSync(path.join(addonDir, 'addon.json'), indexContent, { spaces: 2 });
+      return addonDir;
+    }
+  },
+  '@m3/material': {
+    name: 'Material 3',
+    type: 'design-system',
+    install: async (targetDir) => {
+      const addonDir = path.join(targetDir, 'g360', 'addons', 'm3-material');
+      fs.mkdirpSync(addonDir);
+      fs.writeJsonSync(path.join(addonDir, 'addon.json'), {
+        name: 'm3-material',
+        source: '@m3/material',
+        installedAt: new Date().toISOString()
+      }, { spaces: 2 });
+      return addonDir;
+    }
+  }
+};
+
+export async function addon(command, options) {
+  const { package: pkg, path: targetPath = '.', dryRun = false, force = false } = options;
+  
+  console.log(chalk.bold.cyan('\n📦 G360 Addon Manager\n'));
+  
+  if (command === 'install' || command === 'add') {
+    return installAddon(pkg, targetPath, dryRun, force);
+  }
+  
+  if (command === 'list') {
+    return listAddons(targetPath);
+  }
+  
+  if (command === 'remove' || command === 'uninstall') {
+    return removeAddon(pkg, targetPath, force);
+  }
+  
+  console.log(chalk.yellow('Usage:'));
+  console.log(chalk.gray('  g360 addon install <package>'));
+  console.log(chalk.gray('  g360 addon list'));
+  console.log(chalk.gray('  g360 addon remove <package>'));
+}
+
+async function installAddon(pkg, targetPath, dryRun, force) {
+  if (!pkg) {
+    console.error(chalk.red('❌ Package name required'));
+    console.log(chalk.gray('\nAvailable addons:'));
+    Object.entries(ADDON_REGISTRY).forEach(([key, value]) => {
+      console.log(chalk.gray(`  - ${key} (${value.name})`));
+    });
+    return;
+  }
+  
+  const targetDir = path.resolve(process.cwd(), targetPath);
+  const addonDir = path.join(targetDir, 'g360', 'addons', pkg.replace('@', '').replace('/', '-'));
+  
+  if (fs.existsSync(addonDir) && !force) {
+    console.error(chalk.red(`❌ Addon "${pkg}" already installed`));
+    console.log(chalk.gray('Use --force to reinstall'));
+    return;
+  }
+  
+  if (dryRun) {
+    console.log(chalk.yellow('📋 DRY RUN - Would install:'));
+    console.log(chalk.gray(`  Package: ${pkg}`));
+    console.log(chalk.gray(`  Target: ${addonDir}`));
+    return;
+  }
+  
+  const registryEntry = ADDON_REGISTRY[pkg];
+  
+  try {
+    fs.mkdirpSync(addonDir);
+    
+    if (registryEntry?.install) {
+      await registryEntry.install(targetDir);
+    } else {
+      fs.writeJsonSync(path.join(addonDir, 'addon.json'), {
+        name: pkg,
+        source: pkg,
+        installedAt: new Date().toISOString(),
+        type: 'external'
+      }, { spaces: 2 });
+    }
+    
+    const manifestPath = path.join(targetDir, 'g360', 'manifest.json');
+    if (fs.existsSync(manifestPath)) {
+      const manifest = fs.readJsonSync(manifestPath);
+      if (!manifest.addons) manifest.addons = [];
+      manifest.addons.push({ name: pkg, installedAt: new Date().toISOString() });
+      fs.writeJsonSync(manifestPath, manifest, { spaces: 2 });
+    }
+    
+    console.log(chalk.green(`\n✅ Addon "${pkg}" installed successfully`));
+    console.log(chalk.gray(`   Location: ${addonDir}`));
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error installing addon: ${error.message}`));
+  }
+}
+
+async function listAddons(targetPath) {
+  const targetDir = path.resolve(process.cwd(), targetPath);
+  const addonsDir = path.join(targetDir, 'g360', 'addons');
+  
+  if (!fs.existsSync(addonsDir)) {
+    console.log(chalk.gray('No addons installed'));
+    return;
+  }
+  
+  const addons = fs.readdirSync(addonsDir);
+  
+  if (addons.length === 0) {
+    console.log(chalk.gray('No addons installed'));
+    return;
+  }
+  
+  console.log(chalk.bold.yellow('\n📦 Installed Addons:'));
+  for (const addon of addons) {
+    const addonJsonPath = path.join(addonsDir, addon, 'addon.json');
+    if (fs.existsSync(addonJsonPath)) {
+      const addonData = fs.readJsonSync(addonJsonPath);
+      console.log(chalk.gray(`  - ${addonData.name || addon}`));
+      console.log(chalk.gray(`    Source: ${addonData.source || 'external'}`));
+      console.log(chalk.gray(`    Installed: ${addonData.installedAt || 'unknown'}`));
+    }
+  }
+}
+
+async function removeAddon(pkg, targetPath, force) {
+  if (!pkg) {
+    console.error(chalk.red('❌ Package name required'));
+    return;
+  }
+  
+  const targetDir = path.resolve(process.cwd(), targetPath);
+  const addonDir = path.join(targetDir, 'g360', 'addons', pkg.replace('@', '').replace('/', '-'));
+  
+  if (!fs.existsSync(addonDir)) {
+    console.error(chalk.red(`❌ Addon "${pkg}" not found`));
+    return;
+  }
+  
+  try {
+    fs.removeSync(addonDir);
+    
+    const manifestPath = path.join(targetDir, 'g360', 'manifest.json');
+    if (fs.existsSync(manifestPath)) {
+      const manifest = fs.readJsonSync(manifestPath);
+      if (manifest.addons) {
+        manifest.addons = manifest.addons.filter(a => a.name !== pkg);
+        fs.writeJsonSync(manifestPath, manifest, { spaces: 2 });
+      }
+    }
+    
+    console.log(chalk.green(`\n✅ Addon "${pkg}" removed successfully`));
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error removing addon: ${error.message}`));
+  }
+}

package/src/commands/ingest.js

@@ -4,7 +4,6 @@
  * Procesa archivos ERP y genera maestro_ventas_crm.csv
  */
 
-import { Command } from 'commander';
 import chalk from 'chalk';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -13,87 +12,83 @@ import fs from 'fs-extra';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-export = (program: Command) => {
-  program
-    .command('ingest')
-    .argument('<input>', 'Archivo CSV/Excel o directorio con archivos ERP')
-    .option('-o, --output <archivo>', 'Ruta de salida', 'maestro_ventas_crm.csv')
-    .action(async (input, options) => {
-      console.log(chalk.blue(`\n🚀 Iniciando ingesta: ${input}`));
-
-      const inputPath = path.resolve(input);
-      const outputPath = path.resolve(options.output);
-
-      // Determinar si es archivo o directorio
-      try {
-        await fs.access(inputPath);
-      } catch {
-        console.error(chalk.red(`❌ Ruta no encontrada: ${inputPath}`));
-        process.exit(1);
-      }
+export async function ingest(input, options) {
+  const { output = 'maestro_ventas_crm.csv' } = options;
+  
+  console.log(chalk.blue(`\n🚀 Iniciando ingesta: ${input}`));
 
-      const stat = await fs.stat(inputPath);
-      let filepaths: string[];
-
-      if (stat.isFile()) {
-        filepaths = [inputPath];
-      } else if (stat.isDirectory()) {
-        console.log(chalk.gray(`📁 Escaneando directorio...`));
-        const { valid } = await scanDirectory(inputPath);
-        filepaths = valid.map((info: any) => 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);
-      }
+  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<string, number>();
-        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: any) {
-        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);
+  // 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`);
+      }
+    }
 
-async function scanDirectory(dir: string): Promise<{ valid: any[]; invalid: any[] }> {
+  } 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')}')
@@ -109,8 +104,8 @@ for i in invalid[:10]:
 
   const result = await runPython(pyCode);
   const lines = result.stdout.split('\n').filter(l => l.trim());
-  const valid: any[] = [];
-  const invalid: any[] = [];
+  const valid = [];
+  const invalid = [];
 
   for (const line of lines) {
     if (line.startsWith('VALID::')) {
@@ -125,7 +120,7 @@ for i in invalid[:10]:
   return { valid, invalid };
 }
 
-async function runBatchIngest(filepaths: string[]): Promise<string> {
+async function runBatchIngest(filepaths) {
   const pyCode = `
 import sys
 sys.path.insert(0, '${path.join(__dirname, '..', 'py', 'src')}')
@@ -135,7 +130,6 @@ import pandas as pd
 
 filepaths = [${JSON.stringify(filepaths).replace(/"/g, "'")}]
 df = batch_process_files([Path(p) for p in filepaths], merge_results=True)
-# Output as CSV to stdout
 sys.stdout.write(df.to_csv(index=False))
 `;
 
@@ -165,7 +159,7 @@ sys.stdout.write(df.to_csv(index=False))
   });
 }
 
-function runPython(code: string): Promise<{ stdout: string; stderr: string }> {
+function runPython(code) {
   return new Promise((resolve, reject) => {
     const pyExec = process.env.PYTHON || 'python3';
     const proc = spawn(pyExec, ['-c', code], {
@@ -190,4 +184,4 @@ function runPython(code: string): Promise<{ stdout: string; stderr: string }> {
       reject(new Error(`No se pudo ejecutar Python: ${err.message}`));
     });
   });
-}
+}

package/src/commands/scan.js

@@ -4,99 +4,87 @@
  * 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';
+import { spawn } from 'child_process';
 
 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}`));
+export async function scan(directory, options) {
+  const { recursive = true, minScore = 10 } = options;
+  
+  console.log(chalk.blue(`\n🔍 Escaneando directorio: ${directory}`));
 
-      const pyCode = `
+  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
-
-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}")
+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 { 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`);
-          }
-        }
+  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'],
+    });
 
-        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`);
-          }
-        }
+    let stdout = '';
+    let stderr = '';
 
-        if (validCount > 0) {
-          console.log(chalk.cyan('\n💡 Para procesar todos estos archivos:'));
-          console.log(`   g360 ingest "${directorio}" -o maestro_ventas_crm.csv`);
-        }
+    proc.stdout?.on('data', (data) => { stdout += data.toString(); });
+    proc.stderr?.on('data', (data) => { stderr += data.toString(); });
 
-      } 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);
+    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}`));
+    });
+  });
+}