openprompt-lang 1.2.7 → 1.4.0

package/src/boost/validation-loop.js

@@ -0,0 +1,495 @@
+// @use(kind, contract, limit, error)
+// @kind(util)
+// @contract(in: code, kind, profile -> out: feedbackLoop -> { code, history, report } @error: ValidationFailedError, EscalationFailedError)
+// @limit(lines: 300)
+
+/**
+ * Validation Feedback Loop — Módulo OPL Boost
+ *
+ * Sistema post-generación que:
+ * 1. Corre validación OPL sobre el código generado
+ * 2. Retroalimenta errores específicos al agente 'validate'
+ * 3. Reintenta hasta N veces según perfil
+ * 4. Si persiste, escala la complejidad hacia abajo
+ *
+ * Principio: los modelos pequeños son mejores corrigiendo errores
+ * específicos que generando código correcto la primera vez.
+ *
+ * Uso:
+ *   import { feedbackLoop } from './boost/validation-loop.js'
+ *   const result = await feedbackLoop(code, kind, profile)
+ *   // → { code, history: [...], report: { ... } }
+ */
+
+import { execSync } from "child_process"
+import { existsSync, writeFileSync, unlinkSync, mkdirSync } from "fs"
+import { join } from "path"
+
+// ──────────────────────────────────────────────
+// Configuración
+// ──────────────────────────────────────────────
+
+const VALIDATION_CMD = "npx openprompt-lang validate"
+const MAX_RETRIES_DEFAULT = 2
+const TEMP_DIR = join(process.cwd(), ".opencode", "boost", "temp")
+
+// ──────────────────────────────────────────────
+// Errores específicos
+// ──────────────────────────────────────────────
+
+export class ValidationFailedError extends Error {
+  constructor(message, errors) {
+    super(message)
+    this.name = "ValidationFailedError"
+    this.errors = errors
+  }
+}
+
+export class EscalationFailedError extends Error {
+  constructor(task, attempts) {
+    super(`Escalation failed for task "${task}" after ${attempts} attempts`)
+    this.name = "EscalationFailedError"
+    this.task = task
+    this.attempts = attempts
+  }
+}
+
+// ──────────────────────────────────────────────
+// Validación OPL local
+// ──────────────────────────────────────────────
+
+/**
+ * Ejecuta validación OPL sobre código generado.
+ * Escribe el código en un archivo temporal, ejecuta validate, parsea errores.
+ *
+ * @param {string} code - Código a validar
+ * @param {string} kind - Tipo de archivo (hook, component, etc.)
+ * @returns {{ valid: boolean, errors: Array<{ type: string, message: string, line: number }>, raw: string }}
+ */
+export function validateCode(code, kind) {
+  const tempDir = getTempDir()
+  const tempFile = join(tempDir, `_boost_validate_${kind}_${Date.now()}.ts`)
+
+  try {
+    // Escribir archivo temporal
+    if (!existsSync(tempDir)) {
+      mkdirSync(tempDir, { recursive: true })
+    }
+    writeFileSync(tempFile, code, "utf-8")
+
+    // Ejecutar validación
+    let output
+    try {
+      output = execSync(`${VALIDATION_CMD} ${tempFile} 2>&1`, {
+        encoding: "utf-8",
+        timeout: 10000,
+        cwd: process.cwd(),
+      })
+    } catch (execErr) {
+      // validate devuelve código de error si hay problemas
+      output = execErr.stdout || execErr.message || ""
+    }
+
+    // Parsear errores del output
+    const errors = parseValidationOutput(output)
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      raw: output,
+    }
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [{ type: "system", message: `Error ejecutando validación: ${err.message}`, line: 0 }],
+      raw: err.message,
+    }
+  } finally {
+    // Limpiar archivo temporal
+    try { unlinkSync(tempFile) } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Parseo básico del output de openprompt-lang validate.
+ * Busca patrones como: "✖ ERROR file.ts:10 - mensaje"
+ */
+function parseValidationOutput(output) {
+  const errors = []
+  const lines = output.split("\n")
+
+  for (const line of lines) {
+    // Patrones comunes de error
+    const patterns = [
+      /(?:ERROR|error|✖)\s+(.+?)(?::(\d+))?\s*[-–]\s*(.+)/i,
+      /@kind.*missing/i,
+      /@limit.*exceeded/i,
+      /@use.*required/i,
+      /annotation.*error/i,
+      /(@\w+)\(.*\)\s*[-–]\s*(.+)/,
+    ]
+
+    for (const pattern of patterns) {
+      const match = line.match(pattern)
+      if (match) {
+        const [, fileOrType, lineNum, message] = match
+        errors.push({
+          type: inferErrorType(line),
+          message: message || fileOrType || line,
+          line: lineNum ? parseInt(lineNum, 10) : guessErrorLine(line, output),
+          raw: line,
+        })
+        break
+      }
+    }
+
+    // Detectar errores específicos de OPL
+    if (/\bexceeds? maximum lines?\b/i.test(line)) {
+      errors.push({ type: "limit", message: line.trim(), line: 0, raw: line })
+    }
+    if (/\bmissing @kind\b/i.test(line)) {
+      errors.push({ type: "annotation", message: line.trim(), line: 0, raw: line })
+    }
+  }
+
+  return errors
+}
+
+function inferErrorType(line) {
+  if (/@kind|@limit|@use|@contract|@props|@compose|@deps/i.test(line)) return "annotation"
+  if (/limit|lines?|exceeds/i.test(line)) return "limit"
+  if (/type|interface|TypeScript|TS\d+/i.test(line)) return "type"
+  if (/import|export|module/i.test(line)) return "module"
+  if (/syntax|parse|unexpected/i.test(line)) return "syntax"
+  return "general"
+}
+
+function guessErrorLine(line, fullOutput) {
+  // Intentar extraer número de línea de varios patrones
+  const lineMatch = line.match(/:(\d+):/)
+  if (lineMatch) return parseInt(lineMatch[1], 10)
+
+  // Buscar número de línea al inicio
+  const lineNumMatch = line.match(/\((\d+),\d+\)/)
+  if (lineNumMatch) return parseInt(lineNumMatch[1], 10)
+
+  return 0
+}
+
+// ──────────────────────────────────────────────
+// Construcción de feedback para el agente
+// ──────────────────────────────────────────────
+
+/**
+ * Construye el mensaje de feedback para el agente 'validate'.
+ * Le dice exactamente qué está mal y cómo arreglarlo.
+ *
+ * @param {Array} errors - Errores de validación
+ * @param {object} options - Opciones
+ * @returns {string} Mensaje de feedback estructurado
+ */
+export function buildFeedback(errors, options = {}) {
+  if (!errors || errors.length === 0) {
+    return "El código pasó todas las validaciones. No se requieren cambios."
+  }
+
+  const parts = [
+    `## Errores de Validación (${errors.length} encontrados)`,
+    "",
+    "Corrige SOLO los errores listados. No reescribas el código completo.",
+    "Conserva la estructura y lógica original.",
+    "",
+  ]
+
+  for (let i = 0; i < errors.length; i++) {
+    const err = errors[i]
+    parts.push(`### Error ${i + 1}: ${err.type.toUpperCase()}`)
+    if (err.line > 0) parts.push(`Línea: ${err.line}`)
+    parts.push(`Mensaje: ${err.message}`)
+    parts.push("")
+  }
+
+  // Sugerencias de fix según tipo de error
+  parts.push("## Sugerencias de Corrección")
+  parts.push("")
+
+  const seenTypes = new Set(errors.map((e) => e.type))
+  if (seenTypes.has("annotation")) {
+    parts.push("- 🔧 Anotaciones: verifica que @kind, @limit, @use estén presentes y correctos")
+  }
+  if (seenTypes.has("limit")) {
+    parts.push("- 🔧 Límite: extrae lógica a sub-funciones o acorta el archivo")
+  }
+  if (seenTypes.has("type")) {
+    parts.push("- 🔧 Tipos: verifica interfaces, tipos de retorno y parámetros")
+  }
+  if (seenTypes.has("syntax")) {
+    parts.push("- 🔧 Sintaxis: revisa paréntesis, llaves, puntos y coma")
+  }
+  if (seenTypes.has("module")) {
+    parts.push("- 🔧 Módulo: verifica imports y exports")
+  }
+
+  parts.push("")
+  parts.push("Devuelve el código COMPLETO corregido.")
+
+  return parts.join("\n")
+}
+
+// ──────────────────────────────────────────────
+// Escalado de complejidad
+// ──────────────────────────────────────────────
+
+/**
+ * Reduce la complejidad de una tarea cuando el validation loop falla.
+ *
+ * Estrategias:
+ *   1. Simplificar: reducir features del código a lo mínimo
+ *   2. Dividir: partir en sub-tareas más pequeñas
+ *   3. Skeleton: usar el skeleton básico sin lógica extra
+ *
+ * @param {string} task - Descripción de la tarea
+ * @param {number} attempt - Intento actual (1-indexed)
+ * @returns {{ description: string, simplified: boolean, strategy: string }}
+ */
+export function escalateDown(task, attempt) {
+  const strategies = [
+    // Intento 1: sin cambios (primer intento)
+    () => ({ description: task, simplified: false, strategy: "initial" }),
+
+    // Intento 2: simplificar descripción
+    () => ({
+      description: task
+        .replace(/con .+/i, "")
+        .replace(/usando .+/i, "")
+        .replace(/que .+/i, "")
+        .replace(/ para .+/i, ""),
+      simplified: true,
+      strategy: "simplify-description",
+    }),
+
+    // Intento 3: solo estructura básica
+    () => ({
+      description: `Genera la estructura básica de ${task.split(" ").slice(0, 3).join(" ")} sin lógica compleja`,
+      simplified: true,
+      strategy: "basic-structure",
+    }),
+
+    // Intento 4: solo skeleton vacío
+    () => ({
+      description: `Genera un esqueleto vacío de ${task.split(" ").slice(0, 3).join(" ")} solo con anotaciones OPL`,
+      simplified: true,
+      strategy: "empty-skeleton",
+    }),
+  ]
+
+  const strategyIndex = Math.min(attempt - 1, strategies.length - 1)
+  return strategies[strategyIndex]()
+}
+
+// ──────────────────────────────────────────────
+// Feedback loop principal
+// ──────────────────────────────────────────────
+
+/**
+ * Ejecuta el validation feedback loop completo.
+ *
+ * @param {string} code - Código generado inicial
+ * @param {string} kind - Tipo de archivo (hook, component, etc.)
+ * @param {object} profile - Perfil Boost
+ * @param {object} [options] - Opciones adicionales
+ * @param {function} [options.onValidate] - Callback por cada intento (para logging)
+ * @param {function} [options.correctWithAgent] - Función asíncrona para corregir código con agente
+ *        Si se omite, se usa el agente 'validate' del pool (BOOST-005)
+ * @returns {Promise<{ code: string, valid: boolean, history: Array, report: object }>}
+ */
+export async function feedbackLoop(code, kind, profile, options = {}) {
+  const maxRetries = profile?.validationLoops ?? MAX_RETRIES_DEFAULT
+  const history = []
+  let currentCode = code
+  let finalValid = false
+  let totalAttempts = 0
+
+  for (let attempt = 1; attempt <= maxRetries + 2; attempt++) {
+    totalAttempts = attempt
+
+    // Validar
+    const validation = validateCode(currentCode, kind)
+    const attemptInfo = {
+      attempt,
+      valid: validation.valid,
+      errorCount: validation.errors.length,
+      errors: validation.errors,
+      timestamp: new Date().toISOString(),
+    }
+
+    history.push(attemptInfo)
+
+    if (options.onValidate) {
+      options.onValidate(attemptInfo)
+    }
+
+    // Si pasa validación, terminamos
+    if (validation.valid) {
+      finalValid = true
+      break
+    }
+
+    // Si es el último intento, intentamos escalar
+    if (attempt >= maxRetries + 1) {
+      const escalated = escalateDown(kind, attempt)
+
+      if (escalated.simplified) {
+        history.push({
+          attempt: attempt + 0.5,
+          action: "escalate-down",
+          strategy: escalated.strategy,
+          description: escalated.description,
+        })
+
+        // Si tenemos función de corrección, la usamos
+        if (options.correctWithAgent) {
+          const corrected = await options.correctWithAgent(currentCode, validation.errors, escalated.description)
+          currentCode = corrected
+          continue
+        }
+
+        // Último recurso: devolver código sin validar con reporte
+        break
+      }
+    }
+
+    // Intentar corregir con el agente validate
+    if (options.correctWithAgent) {
+      const feedback = buildFeedback(validation.errors)
+      const corrected = await options.correctWithAgent(currentCode, validation.errors, feedback)
+      currentCode = corrected
+    } else {
+      // Sin agente de corrección, no podemos continuar
+      break
+    }
+  }
+
+  // Generar reporte
+  const report = generateReport(history, totalAttempts, finalValid)
+
+  return {
+    code: currentCode,
+    valid: finalValid,
+    history,
+    report,
+  }
+}
+
+// ──────────────────────────────────────────────
+// Reporte de calidad
+// ──────────────────────────────────────────────
+
+/**
+ * Genera un reporte estructurado del proceso de validación.
+ *
+ * @param {Array} history - Historial de intentos
+ * @param {number} totalAttempts - Total de intentos
+ * @param {boolean} finalValid - Si el código final es válido
+ * @returns {object} Reporte estructurado
+ */
+export function generateReport(history, totalAttempts, finalValid) {
+  const errorHistory = history.filter((h) => h.errors && h.errors.length > 0)
+  const allErrors = errorHistory.flatMap((h) => h.errors || [])
+
+  // Agrupar errores por tipo
+  const errorTypes = {}
+  for (const err of allErrors) {
+    errorTypes[err.type] = (errorTypes[err.type] || 0) + 1
+  }
+
+  // Intentos de escalado
+  const escalations = history.filter((h) => h.action === "escalate-down")
+
+  return {
+    finalValid,
+    totalAttempts,
+    errorsFound: allErrors.length,
+    uniqueErrorTypes: Object.keys(errorTypes).length,
+    errorDistribution: errorTypes,
+    escalations: escalations.map((e) => ({ strategy: e.strategy })),
+    summary: finalValid
+      ? `✅ Código válido tras ${totalAttempts} intento(s). ${allErrors.length} error(es) corregido(s).`
+      : `⚠️ Código NO validado tras ${totalAttempts} intento(s). ${allErrors.length} error(es) pendiente(s).`,
+  }
+}
+
+// ──────────────────────────────────────────────
+// Utilidades
+// ──────────────────────────────────────────────
+
+function getTempDir() {
+  return TEMP_DIR
+}
+
+/**
+ * Wrapper simplificado para usar el feedback loop con el agent-pool.
+ *
+ * @param {string} code - Código inicial
+ * @param {string} kind - Tipo de archivo
+ * @param {object} profile - Perfil Boost
+ * @param {object} agentPool - Instancia del AgentPool (importada de agent-pool.js)
+ * @returns {Promise<{ code: string, valid: boolean, report: object }>}
+ */
+export async function feedbackLoopWithAgent(code, kind, profile, agentPool) {
+  return feedbackLoop(code, kind, profile, {
+    async correctWithAgent(currentCode, errors, feedback) {
+      const result = await agentPool.submit("validate", feedback, profile)
+      return result.text
+    },
+    onValidate(info) {
+      if (!info.valid) {
+        console.warn(`  ↻ Intento ${info.attempt}: ${info.errorCount} error(es)`)
+      }
+    },
+  })
+}
+
+/**
+ * Función determinística de validación rápida (sin ejecutar validate CLI).
+ * Útil para pre-validación antes del feedback loop completo.
+ *
+ * @param {string} code - Código a validar
+ * @param {string} kind - Tipo de archivo
+ * @returns {{ valid: boolean, warnings: string[] }}
+ */
+export function quickValidate(code, kind) {
+  const warnings = []
+  const lines = code.split("\n")
+  const lineCount = lines.length
+
+  // Límites por @kind
+  const LIMITS = { hook: 80, component: 120, page: 200, service: 150, store: 100, util: 100 }
+  const limit = LIMITS[kind] || 200
+
+  if (lineCount > limit) {
+    warnings.push(`Excede límite de ${limit} líneas para @kind(${kind}): ${lineCount} líneas`)
+  }
+
+  // Verificar anotaciones mínimas
+  const hasKind = /@kind\(\w+\)/.test(code)
+  if (!hasKind) {
+    warnings.push("Falta anotación @kind()")
+  }
+
+  const hasUse = /@use\(/.test(code)
+  if (!hasUse) {
+    warnings.push("Falta anotación @use()")
+  }
+
+  // Verificar export con nombre
+  const hasNamedExport = /export\s+(function|const|class|interface|type)\s+\w+/.test(code)
+  if (!hasNamedExport) {
+    warnings.push("No se detectó export con nombre")
+  }
+
+  return {
+    valid: warnings.length === 0,
+    warnings,
+  }
+}