g360-cli 1.14.0 → 1.15.1

package/src/commands/docs.js

@@ -4,7 +4,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const BRAND_PATH = path.join(__dirname, '..', '..', 'assets', 'brand', 'brand.json');
+const BRAND_PATH = path.join(__dirname, '..', 'assets', 'brand', 'brand.json');
 
 const LEVELS = ['readme', 'architecture', 'business-rules', 'api', 'dependencies', 'classes', 'code-graph', 'all'];
 
@@ -176,6 +176,7 @@ async function generateLevel(lvl, dir, projectInfo, brand, manifest, skill, dryR
     case 'dependencies': return await generateDependencies(dir, projectInfo, dryRun);
     case 'classes': return await generateClasses(dir, projectInfo, dryRun);
     case 'code-graph': return await generateCodeGraph(dir, projectInfo, dryRun);
+    case 'api': return await generateApi(dir, projectInfo, dryRun);
     default: return null;
   }
 }
@@ -537,6 +538,109 @@ async function generateCodeGraph(dir, projectInfo, dryRun) {
   return 'docs/generated/code_graph.mmd';
 }
 
+async function generateApi(dir, projectInfo, dryRun) {
+  const scan = scanProject(dir);
+  const pyFiles = scan.pyFiles.filter(f => !f.endsWith('__init__.py'));
+  const jsFiles = scan.jsFiles.filter(f => !f.endsWith('.test.js') && !f.endsWith('.spec.js'));
+
+  const exportedFunctions = [];
+  const exportedClasses = [];
+
+  // Python: detectar def y class exportados
+  for (const file of pyFiles) {
+    const filePath = path.join(dir, file);
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const funcMatches = content.match(/^(?:def|async\s+def)\s+(\w+)\s*\(/gm);
+      if (funcMatches) {
+        for (const m of funcMatches) {
+          const name = m.replace(/^(?:async\s+)?def\s+/, '').replace(/\s*\(.*/, '');
+          if (!name.startsWith('_')) {
+            exportedFunctions.push({ file, name, type: 'python' });
+          }
+        }
+      }
+      const classMatches = content.match(/^(?:class)\s+(\w+)/gm);
+      if (classMatches) {
+        for (const m of classMatches) {
+          const name = m.replace(/class\s+/, '').replace(/\s*[:(\{].*/, '');
+          if (!name.startsWith('_')) {
+            exportedClasses.push({ file, name, type: 'python' });
+          }
+        }
+      }
+    } catch { /* skip unreadable */ }
+  }
+
+  // JS/TS: detectar export function y export class
+  for (const file of jsFiles) {
+    const filePath = path.join(dir, file);
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const funcMatches = content.match(/^export\s+(?:async\s+)?function\s+(\w+)/gm);
+      if (funcMatches) {
+        for (const m of funcMatches) {
+          const name = m.replace(/^export\s+(?:async\s+)?function\s+/, '');
+          exportedFunctions.push({ file, name, type: 'javascript' });
+        }
+      }
+      const classMatches = content.match(/^export\s+class\s+(\w+)/gm);
+      if (classMatches) {
+        for (const m of classMatches) {
+          const name = m.replace(/^export\s+class\s+/, '');
+          exportedClasses.push({ file, name, type: 'javascript' });
+        }
+      }
+    } catch { /* skip unreadable */ }
+  }
+
+  if (exportedFunctions.length === 0 && exportedClasses.length === 0) {
+    console.log(chalk.gray('  ⚠ No se encontraron exports publicos. Generando API basica.'));
+  }
+
+  // Generar markdown
+  let md = `# API Reference\n\n`;
+  md += `> Generado automaticamente por \`g360 docs api\`\n\n`;
+
+  if (exportedClasses.length > 0) {
+    md += `## Clases\n\n`;
+    md += `| Clase | Archivo | Tipo |\n`;
+    md += `|-------|---------|------|\n`;
+    for (const c of exportedClasses) {
+      md += `| \`${c.name}\` | \`${c.file}\` | ${c.type} |\n`;
+    }
+    md += `\n`;
+  }
+
+  if (exportedFunctions.length > 0) {
+    md += `## Funciones\n\n`;
+    md += `| Funcion | Archivo | Tipo |\n`;
+    md += `|---------|---------|------|\n`;
+    for (const f of exportedFunctions) {
+      md += `| \`${f.name}\` | \`${f.file}\` | ${f.type} |\n`;
+    }
+    md += `\n`;
+  }
+
+  if (exportedFunctions.length === 0 && exportedClasses.length === 0) {
+    md += `_No se encontraron exports publicos en el proyecto._\n`;
+  }
+
+  const outputDir = path.join(dir, 'docs', 'generated');
+  const outputPath = path.join(outputDir, 'api.md');
+
+  if (dryRun) {
+    console.log(chalk.gray(`  [dry-run] docs/generated/api.md`));
+    console.log(chalk.gray(`  Funciones: ${exportedFunctions.length} | Clases: ${exportedClasses.length}`));
+    return null;
+  }
+
+  await fs.ensureDir(outputDir);
+  await fs.writeFile(outputPath, md, 'utf8');
+  console.log(chalk.green(`  ✅ docs/generated/api.md (${exportedFunctions.length} funciones, ${exportedClasses.length} clases)`));
+  return 'docs/generated/api.md';
+}
+
 function scanProject(dir) {
   const results = {
     files: [],

package/src/commands/ingest.js

@@ -7,7 +7,7 @@
 import chalk from 'chalk';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { spawn } from 'child_process';
+import { runPython, runPythonStdout, g360CorePath } from '../lib/python-runner.js';
 import fs from 'fs-extra';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -38,12 +38,12 @@ export async function ingest(input, options) {
     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'));
+      console.error(chalk.red('❌ No se encontraron archivos ERP validos en el directorio'));
       process.exit(1);
     }
-    console.log(chalk.green(`   Encontrados ${filepaths.length} archivos válidos`));
+    console.log(chalk.green(`   Encontrados ${filepaths.length} archivos validos`));
   } else {
-    console.error(chalk.red(`❌ Ruta no válida: ${inputPath}`));
+    console.error(chalk.red(`❌ Ruta no valida: ${inputPath}`));
     process.exit(1);
   }
 
@@ -90,8 +90,7 @@ export async function ingest(input, options) {
 
 async function scanDirectory(dir) {
   const pyCode = `
-import sys
-sys.path.insert(0, '${path.join(__dirname, '..', 'py', 'src')}')
+${g360CorePath(__dirname)}
 from g360_core.scanner import find_erp_files_in_dir
 from pathlib import Path
 
@@ -102,8 +101,8 @@ 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 { stdout } = await runPython(pyCode);
+  const lines = stdout.split('\n').filter(l => l.trim());
   const valid = [];
   const invalid = [];
 
@@ -122,66 +121,17 @@ for i in invalid[:10]:
 
 async function runBatchIngest(filepaths) {
   const pyCode = `
-import sys
-sys.path.insert(0, '${path.join(__dirname, '..', 'py', 'src')}')
+${g360CorePath(__dirname)}
 from g360_core.scanner import batch_process_files
 from pathlib import Path
 import pandas as pd
+import sys
 
 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}`));
-    });
-  });
+  const { stdout } = await runPython(pyCode);
+  return stdout;
 }
-
-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/init.js

@@ -222,7 +222,7 @@ async function createG360Structure(projectPath, assetsDir) {
     
     const skillJsonPath = path.join(g360Dir, 'skill.json');
     if (!fs.existsSync(skillJsonPath)) {
-      const exampleSkillPath = path.join(assetsDir, 'config/skills.json');
+      const exampleSkillPath = path.join(assetsDir, 'config/agent-skills.json');
       if (fs.existsSync(exampleSkillPath)) {
         await fs.copy(exampleSkillPath, skillJsonPath);
       }

package/src/commands/lint.js

@@ -1,9 +1,7 @@
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+import { walkProject } from '../lib/file-utils.js';
 
 const SEVERITY = {
   CRITICAL: 'critical',
@@ -30,8 +28,8 @@ const PYTHON_NAMING_RULES = {
 const GENERIC_NAMES = ['result', 'data', 'info', 'val', 'obj', 'tmp', 'aux', 'value', 'x', 'y', 'z', 'item', 'elem', 'entry', 'output', 'input', 'res', 'dt'];
 
 export async function lint(targetPath, options) {
-  const { project = '.', level = 'all' } = options;
-  const targetDir = path.join(process.cwd(), project);
+  const { level = 'all', project } = options;
+  const targetDir = project ? path.join(process.cwd(), project) : path.resolve(targetPath || '.');
 
   if (!fs.existsSync(targetDir)) {
     console.error(chalk.red(`❌ Directorio no encontrado: ${targetDir}`));
@@ -93,30 +91,10 @@ function checkNamingConventions(dir) {
   const jsFiles = [];
   const pyFiles = [];
 
-  function walk(d) {
-    const items = fs.readdirSync(d, { withFileTypes: true });
-    for (const item of items) {
-      if (item.name.startsWith('.')) continue;
-      if (item.name === 'node_modules') continue;
-      if (item.name === '__pycache__') continue;
-      if (item.name === '.pytest_cache') continue;
-      if (item.name === 'g360') continue;
-
-      const fullPath = path.join(d, item.name);
-      if (item.isDirectory()) {
-        walk(fullPath);
-      } else if (item.isFile()) {
-        if (item.name.endsWith('.js') && !item.name.endsWith('.test.js')) {
-          jsFiles.push(fullPath);
-        }
-        if (item.name.endsWith('.py') && !item.name.endsWith('__pycache__')) {
-          pyFiles.push(fullPath);
-        }
-      }
-    }
-  }
-
-  walk(dir);
+  walkProject(dir, {
+    onJs: (fullPath) => jsFiles.push(fullPath),
+    onPy: (fullPath) => pyFiles.push(fullPath),
+  });
 
   for (const file of jsFiles) {
     findings.push(...checkJsFileNaming(file, dir));
@@ -271,30 +249,10 @@ function checkDuplicateFunctions(dir) {
   const findings = [];
   const functionMap = new Map();
 
-  function walk(d) {
-    const items = fs.readdirSync(d, { withFileTypes: true });
-    for (const item of items) {
-      if (item.name.startsWith('.')) continue;
-      if (item.name === 'node_modules') continue;
-      if (item.name === '__pycache__') continue;
-      if (item.name === '.pytest_cache') continue;
-      if (item.name === 'g360') continue;
-
-      const fullPath = path.join(d, item.name);
-      if (item.isDirectory()) {
-        walk(fullPath);
-      } else if (item.isFile()) {
-        if (item.name.endsWith('.js') && !item.name.endsWith('.test.js')) {
-          extractFunctions(fullPath, 'js', functionMap);
-        }
-        if (item.name.endsWith('.py') && !item.name.endsWith('__pycache__')) {
-          extractFunctions(fullPath, 'py', functionMap);
-        }
-      }
-    }
-  }
-
-  walk(dir);
+  walkProject(dir, {
+    onJs: (fullPath) => extractFunctions(fullPath, 'js', functionMap),
+    onPy: (fullPath) => extractFunctions(fullPath, 'py', functionMap),
+  });
 
   for (const [name, locations] of functionMap) {
     if (locations.length > 1) {
@@ -411,37 +369,23 @@ function extractFunctions(filePath, lang, functionMap) {
 function checkSyntaxErrors(dir) {
   const findings = [];
 
-  function walk(d) {
-    const items = fs.readdirSync(d, { withFileTypes: true });
-    for (const item of items) {
-      if (item.name.startsWith('.')) continue;
-      if (item.name === 'node_modules') continue;
-      if (item.name === '__pycache__') continue;
-      if (item.name === '.pytest_cache') continue;
-      if (item.name === 'g360') continue;
-
-      const fullPath = path.join(d, item.name);
-      if (item.isDirectory()) {
-        walk(fullPath);
-      } else if (item.isFile()) {
-        if (item.name.endsWith('.js') && !item.name.endsWith('.test.js')) {
-          checkJsSyntax(fullPath, dir, findings);
-        }
-        if (item.name.endsWith('.py')) {
-          checkPySyntax(fullPath, dir, findings);
-        }
-      }
-    }
-  }
+  walkProject(dir, {
+    onJs: (fullPath) => checkJsSyntax(fullPath, dir, findings),
+    onPy: (fullPath) => checkPySyntax(fullPath, dir, findings),
+  });
 
-  walk(dir);
   return findings;
 }
 
 function checkJsSyntax(filePath, projectDir, findings) {
   const relPath = path.relative(projectDir, filePath);
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  // Skip ES modules (import/export) — new Function() no puede parsearlos
+  if (/^(?:import|export)\s/m.test(content)) return;
+
   try {
-    new Function(fs.readFileSync(filePath, 'utf8'));
+    new Function(content);
   } catch (error) {
     findings.push({
       severity: SEVERITY.CRITICAL,
@@ -492,6 +436,20 @@ function checkPySyntax(filePath, projectDir, findings) {
       while (indentStack.length > 1 && indentStack[indentStack.length - 1] > indent) {
         indentStack.pop();
       }
+      // Verificar que la indentacion actual este en el stack
+      if (indentStack.length > 0 && indent !== indentStack[indentStack.length - 1]) {
+        const indentUnit = indentStack.length > 1 ? indentStack[1] - indentStack[0] : 4;
+        if (indent % indentUnit !== 0) {
+          findings.push({
+            severity: SEVERITY.WARNING,
+            file: relPath,
+            type: 'indentation-error',
+            message: `Indentacion inconsistente en linea ${i + 1}: ${indent} espacios (esperado multiplo de ${indentUnit})`,
+            current: `${indent} espacios`,
+            recommended: `Multiplo de ${indentUnit} espacios`,
+          });
+        }
+      }
     }
   }
 }

package/src/commands/scan.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 /**
  * Comando: g360 scan <directorio>
- * Escanea un directorio para detectar archivos ERP válidos.
+ * Escanea un directorio para detectar archivos ERP validos.
  */
 
 import chalk from 'chalk';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { spawn } from 'child_process';
+import { runPythonStdout, g360CorePath } from '../lib/python-runner.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -17,8 +17,7 @@ export async function scan(directory, options) {
   console.log(chalk.blue(`\n🔍 Escaneando directorio: ${directory}`));
 
   const pyCode = `
-import sys
-sys.path.insert(0, '${path.join(__dirname, '..', 'py', 'src')}')
+${g360CorePath(__dirname)}
 from g360_core.scanner import find_erp_files_in_dir
 from pathlib import Path
 import json
@@ -33,22 +32,22 @@ print(json.dumps(result, indent=2))
 `;
 
   try {
-    const result = await runPython(pyCode);
-    const data = JSON.parse(result.stdout);
+    const stdout = await runPythonStdout(pyCode);
+    const data = JSON.parse(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}`));
+    console.log(chalk.green(`   Validos: ${data.stats.valid}`));
+    console.log(chalk.red(`   Invalidos: ${data.stats.invalid}`));
     
     if (data.valid.length > 0) {
-      console.log(chalk.cyan('\n📋 Archivos válidos:'));
+      console.log(chalk.cyan('\n📋 Archivos validos:'));
       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:'));
+      console.log(chalk.yellow('\n⚠️  Archivos invalidos:'));
       data.invalid.forEach(f => {
         console.log(chalk.red(`   ${f.path}: ${f.error_msg}`));
       });
@@ -61,30 +60,3 @@ print(json.dumps(result, indent=2))
     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

@@ -7,7 +7,7 @@
 import chalk from 'chalk';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { spawn } from 'child_process';
+import { runPython, g360CorePath } from '../lib/python-runner.js';
 import fs from 'fs-extra';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -27,7 +27,6 @@ export async function validate(paths, options) {
           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) {
@@ -35,7 +34,6 @@ export async function validate(paths, options) {
           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)) {
@@ -70,20 +68,19 @@ export async function validate(paths, options) {
   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Ó'})`);
+    console.log(`${status} ${filename} (${res.valid ? 'OK' : 'FALLO'})`);
     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 validos`));
 }
 
 async function validateSingleFile(filepath) {
   const pyCode = `
-import sys
-sys.path.insert(0, '${path.join(__dirname, '..', 'py', 'src')}')
+${g360CorePath(__dirname)}
 from g360_core.scanner import ERPScanner
 from pathlib import Path
 
@@ -100,8 +97,8 @@ except Exception as e:
 `;
 
   try {
-    const result = await runPython(pyCode);
-    const lines = result.stdout.split('\n').filter(l => l.trim());
+    const { stdout } = await runPython(pyCode);
+    const lines = stdout.split('\n').filter(l => l.trim());
 
     let valid = false;
     let missing = [];
@@ -121,30 +118,3 @@ except Exception as e:
     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}`));
-    });
-  });
-}