g360-cli 1.14.0 → 1.15.0

package/package.json

@@ -1,71 +1,71 @@
-{
-  "name": "g360-cli",
-  "version": "1.14.0",
-  "description": "CLI tool for bootstrapping G360 projects with standardized structure, assets, identity, and ERP data processing",
-  "type": "module",
-  "main": "src/cli.js",
-  "bin": {
-    "g360": "src/cli.js"
-  },
-  "files": [
-    "src/",
-    "!src/assets/templates/**/node_modules",
-    "!src/assets/templates/**/package-lock.json",
-    "!src/assets/templates/**/__pycache__",
-    "!src/assets/templates/**/.pytest_cache",
-    "py/",
-    "README.md",
-    "LICENSE",
-    "package.json"
-  ],
-  "scripts": {
-    "prepublishOnly": "node -e \"console.log('Use: npm install -g g360-cli')\"",
-    "test": "vitest",
-    "test:watch": "vitest --watch",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest --coverage",
-    "build": "npm run build:portable",
-    "build:portable": "pkg . --targets node18-win-x64 --output dist/g360.exe",
-    "postinstall": "node -e \"try{require('child_process').execSync('python --version',{encoding:'utf8',stdio:'pipe'})}catch{console.log('⚠️  Python no detectado. Instala Python 3.11+ para funcionalidad completa.')}\""
-  },
-  "pkg": {
-    "assets": [
-      "src/assets/**/*",
-      "py/**/*"
-    ],
-    "outputPath": "dist",
-    "scripts": [],
-    "targets": "node18-win-x64"
-  },
-  "keywords": [
-    "g360",
-    "cli",
-    "scaffolding",
-    "generator",
-    "erp",
-    "data-processing"
-  ],
-  "author": "Carlos Cusi",
-  "license": "MIT",
-  "dependencies": {
-    "ajv": "^8.20.0",
-    "chalk": "^5.6.2",
-    "commander": "^14.0.3",
-    "fs-extra": "^11.3.4",
-    "inquirer": "^13.4.2",
-    "ora": "^9.4.0",
-    "winston": "^3.19.0"
-  },
-  "devDependencies": {
-    "@vitest/ui": "^4.1.6",
-    "pkg": "^5.8.1",
-    "vitest": "^4.1.6"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ccusi/g360-cli.git"
-  }
-}
+{
+  "name": "g360-cli",
+  "version": "1.15.0",
+  "description": "CLI tool for bootstrapping G360 projects with standardized structure, assets, identity, and ERP data processing",
+  "type": "module",
+  "main": "src/cli.js",
+  "bin": {
+    "g360": "src/cli.js"
+  },
+  "files": [
+    "src/",
+    "!src/assets/templates/**/node_modules",
+    "!src/assets/templates/**/package-lock.json",
+    "!src/assets/templates/**/__pycache__",
+    "!src/assets/templates/**/.pytest_cache",
+    "py/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "scripts": {
+    "prepublishOnly": "node -e \"console.log('Use: npm install -g g360-cli')\"",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "build": "npm run build:portable",
+    "build:portable": "pkg . --targets node18-win-x64 --output dist/g360.exe",
+    "postinstall": "node -e \"try{require('child_process').execSync('python --version',{encoding:'utf8',stdio:'pipe'})}catch{console.log('⚠️  Python no detectado. Instala Python 3.11+ para funcionalidad completa.')}\""
+  },
+  "pkg": {
+    "assets": [
+      "src/assets/**/*",
+      "py/**/*"
+    ],
+    "outputPath": "dist",
+    "scripts": [],
+    "targets": "node18-win-x64"
+  },
+  "keywords": [
+    "g360",
+    "cli",
+    "scaffolding",
+    "generator",
+    "erp",
+    "data-processing"
+  ],
+  "author": "Carlos Cusi",
+  "license": "MIT",
+  "dependencies": {
+    "ajv": "^8.20.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.4",
+    "inquirer": "^13.4.2",
+    "ora": "^9.4.0",
+    "winston": "^3.19.0"
+  },
+  "devDependencies": {
+    "@vitest/ui": "^4.1.6",
+    "pkg": "^5.8.1",
+    "vitest": "^4.1.6"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ccusi/g360-cli.git"
+  }
+}

package/src/assets/config/g360-skills.json

@@ -318,6 +318,132 @@
         "kpi-glow-cards",
         "rotating-logger"
       ]
+    },
+    {
+      "name": "react-web",
+      "description": "Aplicaciones web con React/JSX - estilo G360 moderno",
+      "device": "pc",
+      "colors": {
+        "bg": "#0b1220",
+        "surface": "#1a2332",
+        "accent": "#00d084",
+        "text": "#f0f4f8",
+        "muted": "#94a3b8",
+        "success": "#22c55e",
+        "warning": "#f59e0b",
+        "error": "#ef4444"
+      },
+      "effects": {
+        "glassmorphism": true,
+        "blur": "12px",
+        "rounded": "12px"
+      },
+      "signature": {
+        "mode": "powered",
+        "text": "powered by G360"
+      },
+      "framework": "react"
+    },
+    {
+      "name": "solid-web",
+      "description": "Aplicaciones web con SolidJS - estilo G360 moderno",
+      "device": "pc",
+      "colors": {
+        "bg": "#0b1220",
+        "surface": "#1a2332",
+        "accent": "#00d084",
+        "text": "#f0f4f8",
+        "muted": "#94a3b8",
+        "success": "#22c55e",
+        "warning": "#f59e0b",
+        "error": "#ef4444"
+      },
+      "effects": {
+        "glassmorphism": true,
+        "blur": "12px",
+        "rounded": "12px"
+      },
+      "signature": {
+        "mode": "powered",
+        "text": "powered by G360"
+      },
+      "framework": "solid"
+    },
+    {
+      "name": "svelte-web",
+      "description": "Aplicaciones web con Svelte/SvelteKit - estilo G360 moderno",
+      "device": "pc",
+      "colors": {
+        "bg": "#0b1220",
+        "surface": "#1a2332",
+        "accent": "#00d084",
+        "text": "#f0f4f8",
+        "muted": "#94a3b8",
+        "success": "#22c55e",
+        "warning": "#f59e0b",
+        "error": "#ef4444"
+      },
+      "effects": {
+        "glassmorphism": true,
+        "blur": "12px",
+        "rounded": "12px"
+      },
+      "signature": {
+        "mode": "powered",
+        "text": "powered by G360"
+      },
+      "framework": "svelte"
+    },
+    {
+      "name": "lit-web",
+      "description": "Aplicaciones web con Lit Web Components - estilo G360 moderno",
+      "device": "pc",
+      "colors": {
+        "bg": "#0b1220",
+        "surface": "#1a2332",
+        "accent": "#00d084",
+        "text": "#f0f4f8",
+        "muted": "#94a3b8",
+        "success": "#22c55e",
+        "warning": "#f59e0b",
+        "error": "#ef4444"
+      },
+      "effects": {
+        "glassmorphism": true,
+        "blur": "12px",
+        "rounded": "12px"
+      },
+      "signature": {
+        "mode": "powered",
+        "text": "powered by G360"
+      },
+      "framework": "lit"
+    },
+    {
+      "name": "customtkinter",
+      "description": "Aplicaciones desktop con CustomTkinter - estilo G360 moderno",
+      "device": "pc",
+      "colors": {
+        "bg": "#0b1220",
+        "surface": "#1a2332",
+        "accent": "#00d084",
+        "text": "#f0f4f8",
+        "muted": "#94a3b8",
+        "success": "#22c55e",
+        "warning": "#f59e0b",
+        "error": "#ef4444"
+      },
+      "effects": {
+        "glassmorphism": true,
+        "blur": "12px",
+        "rounded": "12px"
+      },
+      "signature": {
+        "mode": "powered",
+        "text": "powered by G360"
+      },
+      "framework": "customtkinter",
+      "portable": true
     }
   ]
 }

package/src/assets/config/project-types.json

@@ -54,6 +54,14 @@
       "description": "Excel VBA macros",
       "framework": "vba",
       "features": ["excel", "macros", "forms"]
+    },
+    {
+      "id": "python-customtkinter",
+      "name": "Python CustomTkinter Desktop",
+      "description": "Python desktop app with CustomTkinter framework",
+      "framework": "customtkinter",
+      "features": ["desktop", "gui", "cross-platform"],
+      "portable": true
     }
   ]
 }

package/src/assets/snippets/snippets.json

@@ -45,21 +45,25 @@
     {
       "name": "g360-header",
       "description": "Standard G360 header",
+      "language": "html",
       "code": "<header class='g360-header'>...</header>"
     },
     {
       "name": "g360-button",
       "description": "G360 styled button",
+      "language": "html",
       "code": "<button class='g360-btn'>Click</button>"
     },
     {
       "name": "g360-card",
       "description": "G360 card component",
+      "language": "html",
       "code": "<div class='g360-card'>...</div>"
     },
     {
       "name": "g360-badge",
       "description": "G360 status badge",
+      "language": "html",
       "code": "<span class='g360-badge g360-badge-success'>Active</span>"
     },
     {

package/src/assets/templates/lit-web/src/index.js

@@ -5,4 +5,4 @@
  * @version 1.0.0
  */
 
-import './src/components/app-root.js';
+import './components/app-root.js';

package/src/assets/templates/python-flet/pyproject.toml

@@ -8,6 +8,7 @@ authors = [
 requires-python = ">=3.11,<4.0"
 dependencies = [
     "flet>=0.28.3",
+    "numpy>=1.24.0",
     "openpyxl>=3.1.0",
     "pandas>=2.0.0",
     "xlrd>=2.0.0",

package/src/assets/templates/python-flet/src/core/skill.json

@@ -29,7 +29,7 @@
     "name": "G360-App"
   },
   "dependencies": {
-    "flet": ">=0.25.0"
+    "flet": ">=0.28.3"
   },
   "guidelines": {
     "architecture": "src/core (logica), src/ui (componentes), src/export (reportes)",

package/src/assets/templates/python-flet-migrate/pyproject.toml

@@ -7,9 +7,7 @@ authors = [
 ]
 requires-python = ">=3.11,<4.0"
 dependencies = [
-    "flet>=0.25.0",
-    "openpyxl>=3.1.0",
-    "pandas>=2.0.0",
+    "flet>=0.28.3",
 ]
 
 [project.optional-dependencies]

package/src/assets/templates/python-flet-polished/src/core/skill.json

@@ -1,16 +1,16 @@
 {
-  "name": "flet-desktop",
-  "description": "G360 Flet Desktop Application",
+  "name": "flet-desktop-polished",
+  "description": "G360 Flet Polished - Plantilla base con patrones de UI avanzada",
   "framework": "flet",
-  "version": "1.2.0",
-  "python": ">=3.11,<4.0",
+  "version": "1.0.0",
+  "python": ">=3.11",
   "colors": {
     "bg": "#0b1220",
-    "surface": "#1a2332",
-    "accent": "#00d084",
-    "text": "#f0f4f8",
-    "muted": "#94a3b8",
-    "success": "#22c55e",
+    "surface": "#1a2333",
+    "accent": "#34d399",
+    "text": "#f0f6fc",
+    "muted": "#8b949e",
+    "success": "#34d399",
     "warning": "#f59e0b",
     "error": "#ef4444"
   },
@@ -20,8 +20,8 @@
     "rounded": "12px"
   },
   "signature": {
-    "mode": "own",
-    "text": "G360 Desktop"
+    "mode": "powered",
+    "text": "powered by G360"
   },
   "build": {
     "tool": "flet",
@@ -29,13 +29,12 @@
     "name": "G360-App"
   },
   "dependencies": {
-    "flet": ">=0.25.0"
+    "flet": ">=0.28.3"
   },
   "guidelines": {
-    "architecture": "src/core (logica), src/ui (componentes), src/export (reportes)",
-    "naming": "PascalCase para clases UI, camelCase para metodos y variables",
-    "state_management": "Usar atributos de clase para estado, evitar globales",
-    "threading": "Usar threading.Thread para operaciones bloqueantes",
-    "window_config": "width=1350, height=900, resizable=True, theme_mode=DARK"
+    "architecture": "src/core (logica), src/ui (componentes), src/config (theme)",
+    "naming": "PascalCase para clases UI, camelCase para metodos",
+    "state_management": "Usar atributos de clase, hash diff para cache",
+    "threading": "Usar threading.Lock() para operaciones concurrentes"
   }
 }

package/src/assets/templates/solid-web/src/components/App.jsx

@@ -5,7 +5,7 @@
  * @version 1.0.0
  */
 
-export default function App() {
+export default function App(props) {
   const titulo = 'Mi Proyecto G360';
   
   return (
@@ -14,7 +14,7 @@ export default function App() {
         <h1>{titulo}</h1>
       </header>
       <main>
-        <slot />
+        {props.children}
       </main>
     </div>
   );

package/src/commands/clean.js

@@ -7,11 +7,8 @@
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { getAllFiles } from '../lib/file-utils.js';
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
 const DEAD_PATTERNS = [
   'backup', 'backup-old', 'backups',
   'temp', 'tmp', '.tmp',
@@ -292,15 +289,6 @@ async function findOrphanFiles(projectDir, allFiles) {
 
 function analyzeFileOrganization(files) {
   const misplaced = [];
-  const structureRules = {
-    'src/components': ['.js', '.jsx', '.ts', '.tsx', '.svelte', '.vue'],
-    'src/pages': ['.js', '.jsx', '.ts', '.tsx', '.svelte', '.vue'],
-    'src/utils': ['.js', '.ts'],
-    'src/hooks': ['.js', '.ts'],
-    'src/services': ['.js', '.ts'],
-    'src/styles': ['.css', '.scss', '.less'],
-    'src/assets': ['.png', '.jpg', '.svg', '.gif', '.webp']
-  };
 
   const components = files.filter(f => {
     const name = path.basename(f);

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

package/src/lib/file-utils.js

@@ -1,8 +1,14 @@
 import fs from 'fs-extra';
 import path from 'path';
 
-const IGNORE_DIRS = ['node_modules', '.git', 'dist', 'build', '.next', 'out', '.nuxt', 'coverage', '.cache', '.svelte-kit', '__pycache__', '.pytest_cache'];
+const IGNORE_DIRS = ['node_modules', '.git', 'dist', 'build', '.next', 'out', '.nuxt', 'coverage', '.cache', '.svelte-kit', '__pycache__', '.pytest_cache', 'g360'];
 
+/**
+ * Obtiene todos los archivos relativos de un directorio (recursivo)
+ * @param {string} dir - Directorio raiz
+ * @param {string} baseDir - Directorio base para paths relativos
+ * @returns {Promise<string[]>} Lista de paths relativos
+ */
 export async function getAllFiles(dir, baseDir = dir) {
   const files = [];
 
@@ -11,7 +17,7 @@ export async function getAllFiles(dir, baseDir = dir) {
   const items = fs.readdirSync(dir, { withFileTypes: true });
 
   for (const item of items) {
-    if (IGNORE_DIRS.includes(item.name)) continue;
+    if (IGNORE_DIRS.includes(item.name) || item.name.startsWith('.')) continue;
 
     const fullPath = path.join(dir, item.name);
     const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
@@ -25,3 +31,84 @@ export async function getAllFiles(dir, baseDir = dir) {
 
   return files;
 }
+
+/**
+ * Walk recursivo de proyecto con callbacks por tipo de archivo
+ * Consolidacion de los walk() duplicados en lint.js, docs.js, clean.js
+ * @param {string} dir - Directorio a escanear
+ * @param {Object} callbacks - Callbacks por extension
+ * @param {Function} callbacks.onJs - Callback para archivos .js/.jsx
+ * @param {Function} callbacks.onPy - Callback para archivos .py
+ * @param {Function} callbacks.onFile - Callback para cualquier archivo (recibe fullPath, relativePath)
+ * @param {Function} callbacks.onDir - Callback para directorios (recibe relativePath)
+ * @param {Object} options - Opciones extras
+ * @param {number} options.maxDepth - Profundidad maxima (default: 10)
+ * @param {string[]} options.skipDirs - Directorios adicionales a ignorar
+ */
+export function walkProject(dir, callbacks, options = {}) {
+  const { maxDepth = 10, skipDirs = [] } = options;
+  const allSkip = [...IGNORE_DIRS, ...skipDirs];
+
+  function walk(d, depth) {
+    if (depth > maxDepth) return;
+    const items = fs.readdirSync(d, { withFileTypes: true });
+
+    for (const item of items) {
+      if (item.name.startsWith('.') || allSkip.includes(item.name)) continue;
+
+      const fullPath = path.join(d, item.name);
+      const relPath = path.relative(dir, fullPath).replace(/\\/g, '/');
+
+      if (item.isDirectory()) {
+        if (callbacks.onDir) callbacks.onDir(relPath, fullPath);
+        walk(fullPath, depth + 1);
+      } else if (item.isFile()) {
+        if (callbacks.onFile) callbacks.onFile(fullPath, relPath, item.name);
+
+        if (item.name.endsWith('.js') && !item.name.endsWith('.test.js') && !item.name.endsWith('.spec.js')) {
+          if (callbacks.onJs) callbacks.onJs(fullPath, relPath);
+        }
+        if (item.name.endsWith('.jsx') && !item.name.endsWith('.test.jsx')) {
+          if (callbacks.onJs) callbacks.onJs(fullPath, relPath);
+        }
+        if (item.name.endsWith('.ts') && !item.name.endsWith('.test.ts')) {
+          if (callbacks.onJs) callbacks.onJs(fullPath, relPath);
+        }
+        if (item.name.endsWith('.tsx') && !item.name.endsWith('.test.tsx')) {
+          if (callbacks.onJs) callbacks.onJs(fullPath, relPath);
+        }
+        if (item.name.endsWith('.py')) {
+          if (callbacks.onPy) callbacks.onPy(fullPath, relPath);
+        }
+      }
+    }
+  }
+
+  walk(dir, 0);
+}
+
+/**
+ * Obtiene archivos JS/TS de un proyecto (sin tests)
+ * @param {string} dir - Directorio del proyecto
+ * @returns {string[]} Lista de paths absolutos
+ */
+export function getJsFiles(dir) {
+  const files = [];
+  walkProject(dir, {
+    onJs: (fullPath) => files.push(fullPath),
+  });
+  return files;
+}
+
+/**
+ * Obtiene archivos Python de un proyecto (sin __init__.py)
+ * @param {string} dir - Directorio del proyecto
+ * @returns {string[]} Lista de paths absolutos
+ */
+export function getPyFiles(dir) {
+  const files = [];
+  walkProject(dir, {
+    onPy: (fullPath) => files.push(fullPath),
+  });
+  return files;
+}

package/src/lib/python-runner.js

@@ -0,0 +1,77 @@
+/**
+ * @file python-runner.js
+ * @description Runner consolidado para ejecutar codigo Python desde Node.js
+ * @author @carloscus
+ * @version 1.0.0
+ */
+
+import { spawn } from 'child_process';
+import path from 'path';
+
+/**
+ * Ejecuta codigo Python y retorna stdout/stderr
+ * @param {string} code - Codigo Python a ejecutar
+ * @param {Object} options - Opciones opcionales
+ * @param {string} options.pythonPath - Ruta al interprete Python
+ * @param {number} options.timeout - Timeout en ms
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+export function runPython(code, options = {}) {
+  const { pythonPath, timeout } = options;
+
+  return new Promise((resolve, reject) => {
+    const pyExec = pythonPath || process.env.PYTHON || 'python3';
+    const proc = spawn(pyExec, ['-c', code], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let timer;
+
+    if (timeout) {
+      timer = setTimeout(() => {
+        proc.kill();
+        reject(new Error(`Python timeout despues de ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout?.on('data', (data) => { stdout += data.toString(); });
+    proc.stderr?.on('data', (data) => { stderr += data.toString(); });
+
+    proc.on('close', (code) => {
+      if (timer) clearTimeout(timer);
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        reject(new Error(stderr || `Python termino con codigo ${code}`));
+      }
+    });
+
+    proc.on('error', (err) => {
+      if (timer) clearTimeout(timer);
+      reject(new Error(`No se pudo ejecutar Python: ${err.message}`));
+    });
+  });
+}
+
+/**
+ * Ejecuta codigo Python y retorna solo stdout
+ * @param {string} code - Codigo Python a ejecutar
+ * @param {Object} options - Mismas opciones que runPython
+ * @returns {Promise<string>} stdout
+ */
+export async function runPythonStdout(code, options = {}) {
+  const { stdout } = await runPython(code, options);
+  return stdout;
+}
+
+/**
+ * Crea el prefijo de Python para importar desde src/py/src
+ * @param {string} commandDir - Directorio del comando que invoca (usar __dirname o import.meta)
+ * @returns {string} Lineas Python para sys.path.insert
+ */
+export function g360CorePath(commandDir) {
+  const pySrc = path.join(commandDir, '..', 'py', 'src').replace(/\\/g, '\\\\');
+  return `import sys\nsys.path.insert(0, '${pySrc}')`;
+}

package/src/assets/templates/python-cli/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "python-cli-template",
-  "version": "1.0.0",
-  "description": "G360 Python CLI Template",
-  "main": "src/main.py",
-  "requirements": []
-}