openprompt-lang 0.3.0 → 0.4.0

package/src/commands/scaffold.js

@@ -0,0 +1,127 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync, copyFileSync } from "fs"
+import { join, dirname } from "path"
+import { fileURLToPath } from "url"
+import chalk from "chalk"
+import { getStructure, getLanguages } from "../utils/language-loader.js"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const STRUCTURES_PATH = join(__dirname, "..", "..", "schemas", "structures.json")
+
+function getStructureFromCatalog(framework) {
+  if (!existsSync(STRUCTURES_PATH)) return null
+  const catalog = JSON.parse(readFileSync(STRUCTURES_PATH, "utf-8"))
+  return catalog[framework] || null
+}
+
+function resolveStructure(framework) {
+  // Priority 1: Language module
+  const langStructure = getStructure(framework)
+  if (langStructure) return { source: "module", data: langStructure }
+
+  // Priority 2: structures.json catalog
+  const catalog = getStructureFromCatalog(framework)
+  if (catalog) return { source: "catalog", data: catalog }
+
+  return null
+}
+
+export async function scaffoldFolders(framework, options) {
+  const cwd = process.cwd()
+  const resolved = resolveStructure(framework)
+
+  if (!resolved) {
+    console.log(chalk.red(`\n❌ Framework "${framework}" not found`))
+    console.log(chalk.cyan(`   Run: npx openPrompt-Lang scaffold list\n`))
+    return
+  }
+
+  const { data: structure } = resolved
+  const projectDir = options.name ? join(cwd, options.name) : cwd
+  const name = structure.name || framework
+
+  console.log(chalk.cyan(`\n🏗️  Scaffolding: ${name}\n`))
+
+  if (options.name) {
+    mkdirSync(projectDir, { recursive: true })
+  }
+
+  // Create folders
+  const folders = structure.folders || []
+  for (const dir of folders) {
+    const fullPath = join(projectDir, dir)
+    mkdirSync(fullPath, { recursive: true })
+    console.log(`  📁 ${dir}/`)
+  }
+
+  // Copy scaffolds
+  const scaffolds = structure.scaffolds || []
+  const scaffoldsDir = join(__dirname, "..", "..", "scaffolds")
+  for (const file of scaffolds) {
+    const srcFile = join(scaffoldsDir, file)
+    if (existsSync(srcFile)) {
+      const destFile = join(projectDir, file)
+      if (!existsSync(destFile) || options.force) {
+        const content = readFileSync(srcFile, "utf-8")
+        writeFileSync(destFile, content, "utf-8")
+        console.log(`  ✅ ${file}`)
+      } else {
+        console.log(`  ⚠️  ${file} already exists. Use --force to overwrite.`)
+      }
+    } else {
+      console.log(`  ⚠️  Scaffold ${file} not found in scaffolds/.`)
+    }
+  }
+
+  console.log(chalk.green(`\n✅ Structure "${name}" created in ${projectDir}\n`))
+  return projectDir
+}
+
+export async function scaffoldList() {
+  // Collect from both sources
+  const seen = new Set()
+  const entries = []
+
+  // From language modules
+  const langs = getLanguages()
+  for (const lang of langs) {
+    const struct = lang.structure
+    if (struct) {
+      seen.add(lang.id)
+      entries.push({
+        id: lang.id,
+        name: lang.name,
+        folders: (struct.folders || []).length,
+        scaffolds: (struct.scaffolds || []).length,
+        source: "module",
+      })
+    }
+  }
+
+  // From structures.json (fallback)
+  if (existsSync(STRUCTURES_PATH)) {
+    const catalog = JSON.parse(readFileSync(STRUCTURES_PATH, "utf-8"))
+    for (const [key, val] of Object.entries(catalog)) {
+      if (!seen.has(key)) {
+        entries.push({
+          id: key,
+          name: val.name || key,
+          folders: (val.folders || []).length,
+          scaffolds: (val.scaffolds || []).length,
+          source: "catalog",
+        })
+      }
+    }
+  }
+
+  if (entries.length === 0) {
+    console.log(chalk.yellow("\n  ⚠️  No structures found.\n"))
+    return
+  }
+
+  console.log(chalk.cyan("\n🏗️  Available frameworks:\n"))
+  for (const entry of entries) {
+    const badge = entry.source === "module" ? chalk.green(" [module]") : chalk.gray(" [catalog]")
+    console.log(`  ${chalk.bold(entry.id)}${badge} — ${entry.name}`)
+    console.log(`     📁 ${entry.folders} folders | 📄 ${entry.scaffolds} scaffolds\n`)
+  }
+}

package/src/commands/suggest.js

@@ -1,31 +1,41 @@
-import chalk from "chalk";
-import { suggestStack } from "../utils/ai.js";
+import chalk from "chalk"
+import { suggestStack } from "../utils/ai.js"
 
 export async function suggest(description) {
-  console.log(chalk.cyan(`\n🤖 Analizando: "${description}"\n`));
+  console.log(chalk.cyan(`\n🤖 Analizando: "${description}"\n`))
 
-  const result = await suggestStack(description);
+  let result
+  try {
+    result = await suggestStack(description)
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`))
+    return
+  }
 
-  if (result.source === "fallback" || !result.stack) {
-    console.log(result.plan);
-    console.log(chalk.yellow("\n📌 No se pudo conectar con IA. Usa el plan anterior con cualquier IA externa.\n"));
-    return;
+  if (!result || result.source === "fallback" || !result.stack) {
+    console.log(result?.plan || "No se pudo generar un plan.")
+    console.log(
+      chalk.yellow(
+        "\n📌 No se pudo conectar con IA. Usa el plan anterior con cualquier IA externa.\n"
+      )
+    )
+    return
   }
 
-  console.log(chalk.green("✅ Stack sugerido:"));
-  console.log(`  ${result.stack.join(", ") || "React + TypeScript + Vite + Tailwind"}`);
+  console.log(chalk.green("✅ Stack sugerido:"))
+  console.log(`  ${result.stack.join(", ") || "React + TypeScript + Vite + Tailwind"}`)
 
   if (result.modules) {
-    console.log(chalk.green("\n📦 Módulos sugeridos:"));
+    console.log(chalk.green("\n📦 Módulos sugeridos:"))
     for (const mod of result.modules) {
-      console.log(`  • ${mod}`);
+      console.log(`  • ${mod}`)
     }
   }
 
   if (result.priorities) {
-    console.log(chalk.green("\n🎯 Prioridades:"));
+    console.log(chalk.green("\n🎯 Prioridades:"))
     for (const p of result.priorities) {
-      console.log(`  ${p}`);
+      console.log(`  ${p}`)
     }
   }
 }

package/src/commands/teach.js

@@ -0,0 +1,110 @@
+import chalk from "chalk"
+import { getTemplate, getLanguage, getLanguageIndex } from "../utils/language-loader.js"
+import { extractLesson, extractTags } from "../utils/template-utils.js"
+
+const TEACH_HEADER = `
+╔══════════════════════════════════════════════════╗
+║  📖 openPrompt-Lang — Template Lesson           ║
+╚══════════════════════════════════════════════════╝
+`
+
+export async function teach(templateId, options) {
+  const langId = options.lang || "react"
+
+  const lang = getLanguage(langId)
+  if (!lang) {
+    console.log(chalk.red(`\n❌ Language "${langId}" not found\n`))
+    return
+  }
+
+  const template = getTemplate(templateId, langId)
+  if (!template) {
+    console.log(chalk.red(`\n❌ Template "${templateId}" not found in ${lang.name}\n`))
+    console.log(chalk.gray(`   Run: npx openPrompt-Lang lang index ${langId}\n`))
+    return
+  }
+
+  const meta = template.metadata
+  const content = template.content
+
+  if (!meta.hasTeachMe && !options.force) {
+    console.log(chalk.yellow(`\n  ⚠️  Template "${templateId}" has no @teachMe annotation.`))
+    console.log(chalk.gray("   Use --force to show raw template anyway.\n"))
+    return
+  }
+
+  console.log(TEACH_HEADER)
+  console.log(chalk.cyan.bold(`\n  📦 ${meta.name}`))
+  console.log(chalk.gray(`  ${meta.description}\n`))
+
+  // Extract teaching content from the @teachMe section
+  const lesson = extractLesson(content)
+
+  if (lesson) {
+    console.log(chalk.yellow.bold("  ─── LESSON ───\n"))
+    console.log(`  ${lesson.replace(/\n/g, "\n  ")}`)
+    console.log("")
+  }
+
+  // Show metadata
+  console.log(chalk.yellow.bold("  ─── TEMPLATE INFO ───\n"))
+  console.log(`  ${chalk.bold("Category:")}    ${meta.category}`)
+  console.log(`  ${chalk.bold("Purposes:")}    ${meta.purposes?.join(", ") || "general"}`)
+  if (meta.variants?.length)
+    console.log(`  ${chalk.bold("Variants:")}    ${meta.variants.join(", ")}`)
+  if (meta.sizes?.length) console.log(`  ${chalk.bold("Sizes:")}       ${meta.sizes.join(", ")}`)
+  console.log(
+    `  ${chalk.bold("Dark mode:")}   ${meta.darkMode ? "✅ Supported" : "❌ Not supported"}`
+  )
+  console.log(`  ${chalk.bold("Responsive:")}  ${meta.responsive ? "✅ Yes" : "❌ No"}`)
+  console.log(`  ${chalk.bold("Deps:")}        ${meta.dependencies?.join(", ") || "none"}`)
+  console.log("")
+
+  // Show fix history
+  if (meta.fixHistory?.length > 0) {
+    console.log(chalk.yellow.bold("  ─── FIX HISTORY (learned errors) ───\n"))
+    const index = getLanguageIndex(langId)
+    const errors = index?.errorsLearned?.filter((e) => meta.fixHistory.includes(e.id)) || []
+    for (const err of errors) {
+      console.log(`  ${chalk.red("⚠️  " + err.id)}`)
+      console.log(`     ${chalk.bold("Problem:")} ${err.problem}`)
+      console.log(`     ${chalk.bold("Fix:")}     ${err.solution}`)
+      console.log(`     ${chalk.gray("Category:")} ${err.category}`)
+      console.log("")
+    }
+  }
+
+  // Show good/bad practices from the template
+  const goodPractices = extractTags(content, "goodPractice")
+  const badPractices = extractTags(content, "badPractice")
+
+  if (goodPractices.length > 0) {
+    console.log(chalk.green.bold("  ─── GOOD PRACTICES ───\n"))
+    for (const gp of goodPractices) {
+      console.log(`  ✅ ${gp}`)
+    }
+    console.log("")
+  }
+
+  if (badPractices.length > 0) {
+    console.log(chalk.red.bold("  ─── BAD PRACTICES TO AVOID ───\n"))
+    for (const bp of badPractices) {
+      console.log(`  ❌ ${bp}`)
+    }
+    console.log("")
+  }
+
+  // Show code (optionally)
+  if (options.code) {
+    console.log(chalk.yellow.bold("  ─── CODE ───\n"))
+    const cleanCode = content
+      .split("\n")
+      .filter((l) => !l.trim().startsWith("// @") && !l.trim().startsWith("// ##"))
+      .join("\n")
+    console.log(cleanCode)
+    console.log("")
+  }
+
+  console.log(chalk.cyan("  ─────────────────────────────────────────\n"))
+  console.log(chalk.gray("  Tip: Use --code to show the full implementation\n"))
+}

package/src/commands/validate.js

@@ -1,183 +1,243 @@
-import { readFileSync, existsSync, readdirSync, statSync } from "fs";
-import { join, extname } from "path";
-import { execSync } from "child_process";
-import chalk from "chalk";
-import { loadConfig, detectStack } from "../utils/config.js";
-import { lintFile } from "../utils/annotations.js";
-
-const CODE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
+// @use(kind, contract, limit)
+// @kind(command)
+// @contract(in: options -> out: void, sideEffect: process.exitCode)
+// @limit(lines: 220)
+// @teachMe
+// ## ¿Qué hace validate.js?
+// Pipeline de 5 pasos: estructura → config → anotaciones → pipeline scripts → resumen.
+// Es el comando principal de verificación del framework.
+// ## ¿Por qué 5 pasos y no solo lint?
+// Porque un proyecto openPrompt-Lang necesita más que anotaciones válidas:
+// necesita estructura de directorios, configuración coherente,
+// y un pipeline de CI que se pueda ejecutar localmente.
+// ## ¿Cómo funciona --fix?
+// --fix solo corrige problemas estructurales (crea directorios, genera
+// prompt-lang.json y AGENTS.md). NO modifica código fuente existente.
+// ## Nota sobre process.exitCode
+// Ya no usa process.exit(1) — establece process.exitCode = 1 para que
+// el proceso termine con código de error sin matar el test runner.
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync } from "fs"
+import { join, extname, relative } from "path"
+import { execSync } from "child_process"
+import chalk from "chalk"
+import { loadConfig, getDefaultConfig } from "../utils/config.js"
+import { lintFile } from "../utils/annotations.js"
+
+const CODE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"])
 
 export async function validate(options) {
-  const baseDir = process.cwd();
-  const config = loadConfig(baseDir);
-  let hasErrors = false;
+  const baseDir = process.cwd()
+  const config = loadConfig(baseDir)
+  const fix = options.fix || false
+  let hasErrors = false
+  let fixCount = 0
 
-  console.log(chalk.cyan("\n🔍 openPrompt-Lang: Validación\n"));
+  console.log(chalk.cyan("\n🔍 openPrompt-Lang: Validación\n"))
 
   // 1. Validar estructura
-  console.log(chalk.yellow("[1/5] Verificando estructura..."));
-  const requiredDirs = ["src", "docs"];
+  console.log(chalk.yellow("[1/5] Verificando estructura..."))
+  const requiredDirs = ["src", "docs"]
   for (const dir of requiredDirs) {
     if (!existsSync(join(baseDir, dir))) {
-      console.log(chalk.red(`  ❌ Falta carpeta: ${dir}/`));
-      hasErrors = true;
+      if (fix) {
+        mkdirSync(join(baseDir, dir), { recursive: true })
+        console.log(chalk.green(`  ✅ ${dir}/ (creado por --fix)`))
+        fixCount++
+      } else {
+        console.log(chalk.red(`  ❌ Falta carpeta: ${dir}/`))
+        hasErrors = true
+      }
     } else {
-      console.log(chalk.green(`  ✅ ${dir}/`));
+      console.log(chalk.green(`  ✅ ${dir}/`))
     }
   }
 
   // 2. Validar config
-  console.log(chalk.yellow("\n[2/5] Verificando configuración..."));
+  console.log(chalk.yellow("\n[2/5] Verificando configuración..."))
   if (existsSync(join(baseDir, "prompt-lang.json"))) {
-    console.log(chalk.green("  ✅ prompt-lang.json"));
+    console.log(chalk.green("  ✅ prompt-lang.json"))
+  } else if (fix) {
+    const defaultConfig = { ...getDefaultConfig(), name: baseDir.split("/").pop() || "mi-proyecto" }
+    writeFileSync(
+      join(baseDir, "prompt-lang.json"),
+      JSON.stringify(defaultConfig, null, 2),
+      "utf-8"
+    )
+    console.log(chalk.green("  ✅ prompt-lang.json (generado por --fix)"))
+    fixCount++
   } else {
-    console.log(chalk.yellow("  ⚠️  No hay prompt-lang.json (usando defaults)"));
+    console.log(chalk.yellow("  ⚠️  No hay prompt-lang.json (usando defaults)"))
   }
 
   if (existsSync(join(baseDir, "AGENTS.md"))) {
-    console.log(chalk.green("  ✅ AGENTS.md"));
+    console.log(chalk.green("  ✅ AGENTS.md"))
+  } else if (fix) {
+    const agentsContent = `# AGENTS.md — Contexto para IA
+
+## Stack
+- ${(config.stack?.base || ["react", "typescript", "vite"]).join("\n- ")}
+
+## Convenciones
+- Framework: openPrompt-Lang (@kind, @contract, @limit annotations)
+- NO any types
+- NO exceed line limits without refactoring
+- Annotations must declare @use() at file start
+- Run validation before every commit
+`
+    writeFileSync(join(baseDir, "AGENTS.md"), agentsContent, "utf-8")
+    console.log(chalk.green("  ✅ AGENTS.md (generado por --fix)"))
+    fixCount++
   } else {
-    console.log(chalk.yellow("  ⚠️  No hay AGENTS.md (recomendado)"));
+    console.log(chalk.yellow("  ⚠️  No hay AGENTS.md (recomendado)"))
   }
 
   // 2b. Validar coherencia stack
-  console.log(chalk.yellow("\n[2b/5] Validando coherencia stack..."));
-  const stack = config.stack || {};
-  const base = (stack.base || []).map(s => s.toLowerCase());
-  const extensions = (stack.extensions || []).map(s => s.toLowerCase());
+  console.log(chalk.yellow("\n[2b/5] Validando coherencia stack..."))
+  const stack = config.stack || {}
+  const base = (stack.base || []).map((s) => s.toLowerCase())
+  const extensions = (stack.extensions || []).map((s) => s.toLowerCase())
 
   if (base.includes("tauri") && !extensions.includes("tauri")) {
-    console.log(chalk.red("  ❌ stack.base incluye 'tauri' pero stack.extensions no lo declara"));
-    hasErrors = true;
+    console.log(chalk.red("  ❌ stack.base incluye 'tauri' pero stack.extensions no lo declara"))
+    hasErrors = true
   } else {
-    console.log(chalk.green("  ✅ stack.base / extensions coherente"));
+    console.log(chalk.green("  ✅ stack.base / extensions coherente"))
   }
 
   // 3. Validar anotaciones PromptLang en archivos
-  console.log(chalk.yellow("\n[3/5] Analizando anotaciones PromptLang..."));
-  let annotatedFiles = 0;
-  let annotationErrors = 0;
-  let annotationWarnings = 0;
-  let platformUsages = new Set();
+  console.log(chalk.yellow("\n[3/5] Analizando anotaciones PromptLang..."))
+  let annotatedFiles = 0
+  let annotationErrors = 0
+  let annotationWarnings = 0
+  let platformUsages = new Set()
 
   const walkDir = (dirPath) => {
-    let entries;
+    let entries
     try {
-      entries = readdirSync(dirPath);
+      entries = readdirSync(dirPath)
     } catch {
-      return;
+      return
     }
     for (const entry of entries) {
-      const fullPath = join(dirPath, entry);
+      const fullPath = join(dirPath, entry)
       try {
-        const stat = statSync(fullPath);
+        const stat = statSync(fullPath)
         if (stat.isDirectory()) {
           if (!entry.startsWith(".") && entry !== "node_modules" && entry !== "dist") {
-            walkDir(fullPath);
+            walkDir(fullPath)
           }
-          continue;
+          continue
         }
       } catch {
-        continue;
+        continue
       }
 
-      const ext = extname(entry).toLowerCase();
-      if (!CODE_EXTENSIONS.has(ext)) continue;
+      const ext = extname(entry).toLowerCase()
+      if (!CODE_EXTENSIONS.has(ext)) continue
 
       try {
-        const content = readFileSync(fullPath, "utf-8");
-        if (!content.includes("@use") && !content.includes("@kind")) continue;
+        const content = readFileSync(fullPath, "utf-8")
+        if (!content.includes("@use") && !content.includes("@kind")) continue
 
-        annotatedFiles++;
-        const { annotations, errors, warnings } = lintFile(content, config.annotations.strict);
+        annotatedFiles++
+        const { annotations, errors, warnings } = lintFile(content, config.annotations?.strict)
 
         // Colectar @platform usages para validación de stack
         for (const ann of annotations) {
-          if (ann.tag === "platform" && ann.args) {
-            ann.args.split(",").forEach(p => platformUsages.add(p.trim()));
+          if (ann.name === "platform") {
+            for (const arg of ann.args) {
+              if (arg.value) platformUsages.add(arg.value.trim())
+            }
           }
         }
 
         if (errors.length > 0 || warnings.length > 0) {
-          const relPath = entry;
+          const relPath = relative(baseDir, fullPath)
           for (const err of errors) {
-            annotationErrors++;
-            console.log(chalk.red(`  ❌ ${relPath}: ${err}`));
+            annotationErrors++
+            console.log(chalk.red(`  ❌ ${relPath}: ${err}`))
           }
           for (const warn of warnings) {
-            annotationWarnings++;
-            console.log(chalk.yellow(`  ⚠️  ${relPath}: ${warn}`));
+            annotationWarnings++
+            console.log(chalk.yellow(`  ⚠️  ${relPath}: ${warn}`))
           }
         }
       } catch {
         // skip
       }
     }
-  };
+  }
 
-  walkDir(join(baseDir, "src"));
+  walkDir(join(baseDir, "src"))
 
   if (annotatedFiles === 0) {
-    console.log(chalk.cyan("  📭 No se encontraron archivos con anotaciones PromptLang"));
+    console.log(chalk.cyan("  📭 No se encontraron archivos con anotaciones PromptLang"))
   } else {
-    console.log(chalk.green(`  📄 ${annotatedFiles} archivos con anotaciones`));
+    console.log(chalk.green(`  📄 ${annotatedFiles} archivos con anotaciones`))
     if (annotationErrors > 0) {
-      hasErrors = true;
-      console.log(chalk.red(`  ❌ ${annotationErrors} errores`));
+      hasErrors = true
+      console.log(chalk.red(`  ❌ ${annotationErrors} errores`))
     }
     if (annotationWarnings > 0) {
-      console.log(chalk.yellow(`  ⚠️  ${annotationWarnings} advertencias`));
+      console.log(chalk.yellow(`  ⚠️  ${annotationWarnings} advertencias`))
     }
     if (annotationErrors === 0 && annotationWarnings === 0) {
-      console.log(chalk.green(`  ✅ Todas las anotaciones válidas`));
+      console.log(chalk.green(`  ✅ Todas las anotaciones válidas`))
     }
   }
 
   // Validación cruzada: @platform vs stack
   if (platformUsages.size > 0) {
     for (const plat of platformUsages) {
-      if (plat === "mobile" && !extensions.some(e => ["ionic", "capacitor"].includes(e))) {
-        console.log(chalk.yellow(`  ⚠️  @platform(mobile) usado pero stack no incluye ionic/capacitor`));
+      if (plat === "mobile" && !extensions.some((e) => ["ionic", "capacitor"].includes(e))) {
+        console.log(
+          chalk.yellow(`  ⚠️  @platform(mobile) usado pero stack no incluye ionic/capacitor`)
+        )
       }
       if (plat === "desktop" && !extensions.includes("tauri")) {
-        console.log(chalk.yellow(`  ⚠️  @platform(desktop) usado pero stack no incluye tauri`));
+        console.log(chalk.yellow(`  ⚠️  @platform(desktop) usado pero stack no incluye tauri`))
       }
     }
   }
 
   // 4. Ejecutar pipeline configurado
-  console.log(chalk.yellow("\n[4/5] Ejecutando pipeline..."));
-  const scripts = config.pipeline?.scripts || {};
-  const pipelineSteps = config.pipeline?.["pre-commit"] || [];
+  console.log(chalk.yellow("\n[4/5] Ejecutando pipeline..."))
+  const scripts = config.pipeline?.scripts || {}
+  const pipelineSteps = config.pipeline?.["pre-commit"] || []
 
   if (pipelineSteps.length === 0) {
-    console.log(chalk.cyan("  📭 No hay pipeline configurado"));
+    console.log(chalk.cyan("  📭 No hay pipeline configurado"))
   } else {
     for (const step of pipelineSteps) {
-      const scriptCmd = scripts[step];
+      const scriptCmd = scripts[step]
       if (!scriptCmd) {
-        console.log(chalk.yellow(`  ⚠️  Paso "${step}" sin script configurado`));
-        continue;
+        console.log(chalk.yellow(`  ⚠️  Paso "${step}" sin script configurado`))
+        continue
       }
       try {
-        process.stdout.write(`  ▶️  ${step}... `);
-        execSync(scriptCmd, { cwd: baseDir, stdio: "pipe" });
-        console.log(chalk.green("✅"));
+        process.stdout.write(`  ▶️  ${step}... `)
+        execSync(scriptCmd, { cwd: baseDir, stdio: "pipe" })
+        console.log(chalk.green("✅"))
       } catch (err) {
-        console.log(chalk.red("❌"));
-        hasErrors = true;
-        console.log(chalk.red(`     ${err.stderr?.toString().split("\n")[0] || "Error"}`));
+        console.log(chalk.red("❌"))
+        hasErrors = true
+        console.log(chalk.red(`     ${err.stderr?.toString().split("\n")[0] || "Error"}`))
       }
     }
   }
 
   // 5. Resumen
-  console.log(chalk.yellow("\n[5/5] Resumen\n"));
+  console.log(chalk.yellow("\n[5/5] Resumen\n"))
+
+  if (fixCount > 0) {
+    console.log(chalk.green(`  🔧 ${fixCount} problema(s) corregido(s) por --fix\n`))
+  }
 
   if (hasErrors) {
-    console.log(chalk.red("❌ Validación falló — revisa los errores arriba\n"));
-    process.exit(1);
+    console.log(chalk.red("❌ Validación falló — revisa los errores arriba\n"))
+    process.exitCode = 1
   } else {
-    console.log(chalk.green("✅ Validación completa — todo correcto\n"));
+    console.log(chalk.green("✅ Validación completa — todo correcto\n"))
   }
 }