openprompt-lang 1.2.7 → 1.4.0

package/src/boost/orchestrator.js

@@ -0,0 +1,615 @@
+// @use(kind, contract, limit, error)
+// @kind(util)
+// @contract(in: task, options -> out: boost -> { code, metadata, report } @error: BoostPipelineError)
+// @limit(lines: 350)
+
+/**
+ * Boost Orchestrator — Pipeline de generación multi-etapa.
+ *
+ * Orquesta todos los componentes Boost en un flujo coherente.
+ * Soporta dos modos:
+ *
+ * **Single-pass** (default): compress → few-shot → hydrate → quick-validate
+ *   Usa el Agent Pool solo para la generación central.
+ *
+ * **Multi-agent** (opt-in): compress → dispatch DAG → agent pool → assemble → validate
+ *   Usa agentes especializados para cada parte del código.
+ *
+ * Uso:
+ *   import { boost } from './boost/orchestrator.js'
+ *   const result = await boost('crea hook useAuth con Supabase', {
+ *     kind: 'hook',
+ *     profile: 'medium',
+ *   })
+ *   // → { code, metadata: { duration, stages: [...], profile }, report }
+ */
+
+import { getProfile, isBoostEnabled } from "./profile-registry.js"
+import { compressContext, compressAgentsMd } from "./context-compressor.js"
+import { retrieveExamples, buildFewShotPrompt } from "./fewshot-retriever.js"
+import { hydrate, hydrateFromAgentResults } from "./hydrator.js"
+import { quickValidate, validateCode, feedbackLoop } from "./validation-loop.js"
+import { plan, detectKind } from "./task-dispatcher.js"
+import { agentPool } from "./agent-pool.js"
+
+// ──────────────────────────────────────────────
+// Configuración
+// ──────────────────────────────────────────────
+
+const DEFAULT_OPTIONS = {
+  profile: null,        // auto-detect
+  kind: null,           // auto-detect
+  dryRun: false,        // solo mostrar plan
+  output: null,         // archivo de salida (opcional)
+  validate: true,       // ejecutar validation loop
+  multiAgent: false,    // usar multi-agente (opt-in)
+  contextMode: "safe",  // modo de compresión: safe | aggressive | disabled
+  maxExamples: 3,       // máx ejemplos few-shot
+}
+
+// ──────────────────────────────────────────────
+// Pipeline stages
+// ──────────────────────────────────────────────
+
+/**
+ * Stage 0: Detectar perfil
+ */
+function stageProfile(options) {
+  const startTime = Date.now()
+  const profile = options.profile || getProfile()
+  return {
+    name: "profile-detect",
+    duration: Date.now() - startTime,
+    result: profile ? { name: profile.name, mode: profile.agentPool?.mode || "queue" } : null,
+    profile,
+  }
+}
+
+/**
+ * Stage 1: Comprimir contexto
+ */
+function stageCompress(task, kind, profile, options) {
+  const startTime = Date.now()
+
+  // Comprimir AGENTS.md
+  const compressed = compressAgentsMd(task, profile, {
+    mode: options.contextMode || "safe",
+    kind,
+  })
+
+  return {
+    name: "context-compress",
+    duration: Date.now() - startTime,
+    result: compressed
+      ? {
+          originalChars: compressed.metrics.originalChars,
+          compressedChars: compressed.metrics.compressedChars,
+          reductionPercent: compressed.metrics.reductionPercent,
+          sectionsKept: compressed.metrics.sectionsKept,
+        }
+      : null,
+    compressed,
+  }
+}
+
+/**
+ * Stage 2: Buscar ejemplos few-shot
+ */
+function stageFewShot(task, kind, options) {
+  const startTime = Date.now()
+
+  const examples = retrieveExamples(kind, task, {
+    maxExamples: options.maxExamples || 3,
+  })
+
+  return {
+    name: "fewshot-retrieve",
+    duration: Date.now() - startTime,
+    result: {
+      examplesFound: examples.length,
+      sources: examples.map((e) => e.file),
+    },
+    examples,
+  }
+}
+
+/**
+ * Stage 3: DAG planning (solo multi-agent)
+ */
+function stagePlan(task, kind) {
+  const startTime = Date.now()
+  const dag = plan(task, kind)
+
+  return {
+    name: "task-plan",
+    duration: Date.now() - startTime,
+    result: {
+      kind: dag.kind,
+      nodes: dag.nodeCount,
+      parallel: dag.stages.parallel.length,
+      sequential: dag.stages.sequential.length,
+    },
+    dag,
+  }
+}
+
+/**
+ * Stage 4: Generar código con Agent Pool
+ */
+async function stageGenerate(task, kind, compressed, examples, dag, profile, options) {
+  const startTime = Date.now()
+
+  if (options.multiAgent) {
+    // MODO MULTI-AGENTE: ejecutar DAG con agentes especializados
+    return await stageGenerateMultiAgent(task, kind, compressed, examples, dag, profile, options)
+  }
+
+  // MODO SINGLE-PASS: generar con un solo agente (logic)
+  // El agente recibe contexto comprimido + ejemplos + instrucciones
+  const context = compressed?.context || ""
+  const fewShotPrompt = examples.length > 0
+    ? buildFewShotPrompt(examples, `Genera un ${kind} para: ${task}`)
+    : `Genera un ${kind} para: ${task}`
+
+  const fullPrompt = [
+    context ? `## Contexto del Proyecto\n\n${context.substring(0, 2000)}\n\n` : "",
+    fewShotPrompt,
+  ].join("")
+
+  const result = await agentPool.submit("logic", fullPrompt, profile)
+  const code = result.text
+
+  return {
+    name: "generate",
+    duration: Date.now() - startTime,
+    result: {
+      mode: "single-pass",
+      tokensPerSecond: result.metrics?.tokensPerSecond,
+      tokenCount: result.metrics?.tokenCount,
+      codeLength: code.length,
+    },
+    code,
+    agentMetrics: result.metrics,
+  }
+}
+
+/**
+ * Stage 4b: Generación multi-agente (DAG)
+ */
+async function stageGenerateMultiAgent(task, kind, compressed, examples, dag, profile, options) {
+  const startTime = Date.now()
+  const context = compressed?.context || ""
+  const results = {}
+
+  // Fase paralela: nodos sin dependencias
+  const parallelNodes = dag.nodes.filter((n) => n.deps.length === 0)
+  const parallelResults = await Promise.all(
+    parallelNodes.map(async (node) => {
+      const agentInput = [
+        task,
+        context ? `\nContexto:\n${context.substring(0, 1000)}` : "",
+        examples.length > 0 ? `\nEjemplos:\n${examples.map((e) => e.file).join(", ")}` : "",
+      ].join("\n")
+
+      const result = await agentPool.submit(node.agent, agentInput, profile)
+      return { nodeId: node.id, ...result }
+    })
+  )
+
+  for (const r of parallelResults) {
+    results[r.nodeId] = r.text
+  }
+
+  // Fase secuencial: nodos con dependencias
+  const sequentialNodes = dag.nodes.filter((n) => n.deps.length > 0)
+  for (const node of sequentialNodes) {
+    // Armar input con resultados de dependencias
+    const depsOutput = node.deps.map((depId) => {
+      const depNode = dag.nodes.find((n) => n.id === depId)
+      return `### ${depNode?.description || depId}\n${results[depId] || ""}`
+    }).join("\n\n")
+
+    const agentInput = [
+      `Task: ${task}`,
+      `Kind: ${kind}`,
+      "",
+      "Outputs from previous agents:",
+      depsOutput,
+      "",
+      `Your role: ${node.description}`,
+    ].join("\n")
+
+    const result = await agentPool.submit(node.agent, agentInput, profile)
+    results[node.id] = result.text
+  }
+
+  // Ensamblar resultados en código final
+  // Extraer nombre de la tarea para el hydrator
+  const taskName = extractNameFromTask(task)
+  const assembledCode = assembleFromDAG(kind, results, taskName)
+  const hydratorStart = Date.now()
+
+  // Aplicar la misma lógica de smart detection que stageHydrate
+  const hasImports = /^import\s/m.test(assembledCode)
+  const hasExport = /^export\s/m.test(assembledCode)
+
+  let finalCode
+  let hydrationResult
+
+  if (hasImports && hasExport) {
+    // Código completo del LLM — solo inyectar anotaciones
+    const annotations = generateOPLAnnotations(kind, assembledCode)
+    finalCode = annotations + "\n\n" + assembledCode.trim()
+    hydrationResult = { hydrated: false, reason: "multi-agent-complete-injection" }
+  } else {
+    // Código parcial — hidratar con skeleton
+    const hydrated = hydrateFromAgentResults(kind, { ...results, name: taskName })
+    finalCode = hydrated.code || assembledCode
+    hydrationResult = { hydrated: true, warnings: hydrated.warnings.length }
+  }
+
+  return {
+    name: "generate",
+    duration: Date.now() - startTime,
+    result: {
+      mode: "multi-agent",
+      parallelNodes: parallelNodes.length,
+      sequentialNodes: sequentialNodes.length,
+      agentResults: Object.keys(results).length,
+    },
+    code: finalCode,
+    agentResults: results,
+  }
+}
+
+/**
+ * Ensamblado básico de resultados multi-agente.
+ */
+function assembleFromDAG(kind, results, taskName) {
+  const parts = []
+  if (results.types) parts.push(results.types)
+  if (results.state) parts.push(results.state)
+  if (results.logic) parts.push(results.logic)
+  return parts.join("\n\n")
+}
+
+/**
+ * Stage 5: Hidratar código final
+ *
+ * Estrategia de hidratación:
+ * 1. Si el código ya tiene @kind() → usar directo (ya anotado)
+ * 2. Si el código tiene imports + exports → código completo del LLM, solo inyectar anotaciones
+ * 3. Si es código parcial → hidratar con skeleton
+ */
+function stageHydrate(kind, code, profile) {
+  const startTime = Date.now()
+
+  // Caso 1: Si el código ya tiene anotaciones OPL, usarlo directamente
+  if (/@kind\(/.test(code)) {
+    return {
+      name: "hydrate",
+      duration: Date.now() - startTime,
+      result: { hydrated: false, reason: "already-annotated" },
+      code,
+    }
+  }
+
+  // Caso 2: Si el código tiene imports y exports, es código completo del LLM.
+  // No envolver en skeleton — solo agregar anotaciones OPL al inicio.
+  const hasImports = /^import\s/m.test(code)
+  const hasExport = /^export\s/m.test(code)
+
+  if (hasImports && hasExport) {
+    const annotations = generateOPLAnnotations(kind, code)
+    const annotatedCode = annotations + "\n\n" + code.trim()
+
+    return {
+      name: "hydrate",
+      duration: Date.now() - startTime,
+      result: { hydrated: false, reason: "llm-complete-injection" },
+      code: annotatedCode,
+    }
+  }
+
+  // Caso 3: Código parcial — hidratar con skeleton template
+  const hydrated = hydrate(kind, {
+    imports: "",
+    types: "",
+    logic: code,
+    name: "Generated",
+    props: "",
+    description: "Generated by OPL Boost",
+  })
+
+  return {
+    name: "hydrate",
+    duration: Date.now() - startTime,
+    result: {
+      hydrated: true,
+      warnings: hydrated.warnings.length,
+      validationsPassed: hydrated.validations.filter((v) => v.passed).length,
+    },
+    code: hydrated.code,
+  }
+}
+
+/**
+ * Extrae el nombre de una función/componente de la descripción de la tarea.
+ * Ejemplos:
+ *   "hook useAuth para autenticación" → "useAuth"
+ *   "service ProductService para ecommerce" → "ProductService"
+ *   "store useCartStore con zustand" → "useCartStore"
+ *   "componente ProductCard" → "ProductCard"
+ */
+function extractNameFromTask(task) {
+  // Patrón: kind name (hook useAuth, service ProductService, etc.)
+  const kindNamePattern = /\b(?:hook|service|store|component|page|util)\s+(use\w+|[A-Z]\w*(?:Service|Store|Component|Page|Hook|Manager|Handler))\b/i
+  const kindNameMatch = task.match(kindNamePattern)
+  if (kindNameMatch) return kindNameMatch[1]
+
+  // Patrón: useXxx (nombre de hook)
+  const hookPattern = /\b(use\w+)\b/i
+  const hookMatch = task.match(hookPattern)
+  if (hookMatch) return hookMatch[1]
+
+  // Patrón: XxxService, XxxStore, XxxComponent
+  const pascalPattern = /\b([A-Z]\w+(?:Service|Store|Component|Page|Manager|Handler))\b/
+  const pascalMatch = task.match(pascalPattern)
+  if (pascalMatch) return pascalMatch[1]
+
+  // Patrón: cualquier palabra PascalCase
+  const camelPattern = /\b([A-Z][a-zA-Z]+)\b/
+  const camelMatch = task.match(camelPattern)
+  if (camelMatch) return camelMatch[1]
+
+  return "Generated"
+}
+
+/**
+ * Genera anotaciones OPL para inyectar al inicio de un archivo completo del LLM.
+ */
+function generateOPLAnnotations(kind, code) {
+  const lineCount = code.split("\n").length
+  const kindLimits = { hook: 80, component: 120, page: 200, service: 150, store: 100, util: 100 }
+  const limit = kindLimits[kind] || 200
+
+  let annotation = `// @use(kind, contract, limit)\n// @kind(${kind})`
+
+  // Detectar contrato básico del código
+  const exportMatch = code.match(/export\s+(?:async\s+)?function\s+(\w+)/)
+  const funcName = exportMatch ? exportMatch[1] : ""
+  if (funcName) {
+    annotation += `\n// @contract(in: unknown -> out: ${funcName} result @error: Error)`
+  }
+
+  annotation += `\n// @limit(lines: ${limit})`
+
+  return annotation
+}
+
+/**
+ * Stage 6: Validation loop
+ */
+async function stageValidate(kind, code, profile, options) {
+  if (!options.validate) {
+    // Solo quick-validate
+    const startTime = Date.now()
+    const check = quickValidate(code, kind)
+    return {
+      name: "quick-validate",
+      duration: Date.now() - startTime,
+      result: { valid: check.valid, warnings: check.warnings },
+      valid: check.valid,
+      code,
+    }
+  }
+
+  // Feedback loop completo con agente validate
+  const startTime = Date.now()
+  const result = await feedbackLoop(code, kind, profile, {
+    async correctWithAgent(currentCode, errors, feedback) {
+      const agentResult = await agentPool.submit("validate", feedback, profile)
+      return agentResult.text
+    },
+  })
+
+  return {
+    name: "validate",
+    duration: Date.now() - startTime,
+    result: {
+      valid: result.valid,
+      attempts: result.history.length,
+      errorsFound: result.report.errorsFound,
+      summary: result.report.summary,
+    },
+    valid: result.valid,
+    code: result.code,
+    report: result.report,
+  }
+}
+
+// ──────────────────────────────────────────────
+// API principal: boost()
+// ──────────────────────────────────────────────
+
+/**
+ * Orquesta el pipeline completo de generación Boost.
+ *
+ * @param {string} task - Descripción de la tarea
+ * @param {object} [options] - Opciones
+ * @param {string} [options.kind] - Tipo de archivo (auto-detecta si se omite)
+ * @param {object} [options.profile] - Perfil (auto-detecta si se omite)
+ * @param {boolean} [options.dryRun=false] - Solo mostrar plan
+ * @param {string} [options.output] - Archivo de salida
+ * @param {boolean} [options.validate=true] - Ejecutar validation loop
+ * @param {boolean} [options.multiAgent=false] - Usar multi-agente
+ * @param {string} [options.contextMode="safe"] - Modo compresión
+ * @returns {Promise<{ code: string, metadata: object, report: object }>}
+ */
+export async function boost(task, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options }
+  const kind = opts.kind || detectKind(task)
+  const stages = []
+  const startTime = Date.now()
+
+  // Verificar que Boost esté habilitado
+  if (!isBoostEnabled()) {
+    return {
+      code: "",
+      metadata: { error: "Boost deshabilitado en prompt-lang.json" },
+      report: { summary: "Boost deshabilitado. Actívalo con boost.enabled = true" },
+    }
+  }
+
+  // Stage 0: Profile
+  const profileStage = stageProfile(opts)
+  stages.push(profileStage)
+  const profile = profileStage.profile
+
+  if (opts.dryRun) {
+    return dryRun(task, kind, profile, opts)
+  }
+
+  // Stage 1: Compress
+  const compressStage = stageCompress(task, kind, profile, opts)
+  stages.push(compressStage)
+
+  // Stage 2: Few-shot
+  const fewShotStage = stageFewShot(task, kind, opts)
+  stages.push(fewShotStage)
+
+  // Stage 3: Plan
+  const planStage = stagePlan(task, kind)
+  stages.push(planStage)
+
+  // Stage 4: Generate
+  const generateStage = await stageGenerate(
+    task, kind,
+    compressStage.compressed,
+    fewShotStage.examples,
+    planStage.dag,
+    profile, opts
+  )
+  stages.push(generateStage)
+
+  // Stage 5: Hydrate
+  const hydrateStage = stageHydrate(kind, generateStage.code, profile)
+  stages.push(hydrateStage)
+
+  // Stage 6: Validate
+  const validateStage = await stageValidate(kind, hydrateStage.code, profile, opts)
+  stages.push(validateStage)
+
+  // Calcular metadata
+  const totalTime = Date.now() - startTime
+  const code = validateStage.code
+
+  // Guardar a archivo si se especificó
+  if (opts.output && code) {
+    try {
+      const { writeFileSync, mkdirSync, existsSync } = await import("fs")
+      const { dirname, isAbsolute, join: joinPath } = await import("path")
+      // Si la ruta es absoluta, usarla directamente; si es relativa, resolverla desde cwd
+      const outputPath = isAbsolute(opts.output) ? opts.output : joinPath(process.cwd(), opts.output)
+      const outputDir = dirname(outputPath)
+      if (!existsSync(outputDir)) mkdirSync(outputDir, { recursive: true })
+      writeFileSync(outputPath, code, "utf-8")
+    } catch (err) {
+      // Error guardando archivo — no fatal
+      stages.push({
+        name: "output-save",
+        duration: 0,
+        error: err.message,
+      })
+    }
+  }
+
+  const metadata = {
+    task,
+    kind,
+    profile: profile?.name || "unknown",
+    totalTime,
+    stages: stages.map((s) => ({
+      name: s.name,
+      duration: s.duration,
+      result: s.result || null,
+      error: s.error || null,
+    })),
+    multiAgent: opts.multiAgent,
+    contextMode: opts.contextMode,
+  }
+
+  const report = {
+    summary: validateStage.valid
+      ? `✅ Código generado exitosamente en ${(totalTime / 1000).toFixed(1)}s`
+      : `⚠️ Código generado con advertencias en ${(totalTime / 1000).toFixed(1)}s`,
+    profile: profile?.name || "unknown",
+    totalTime,
+    stagesCompleted: stages.filter((s) => !s.error).length,
+    stagesFailed: stages.filter((s) => s.error).length,
+  }
+
+  return { code, metadata, report }
+}
+
+// ──────────────────────────────────────────────
+// Dry-run
+// ──────────────────────────────────────────────
+
+function dryRun(task, kind, profile, options) {
+  const dag = plan(task, kind)
+
+  return {
+    code: "",
+    metadata: {
+      task,
+      kind,
+      profile: profile?.name || "unknown",
+      dryRun: true,
+      stages: [
+        { name: "profile-detect", planned: true, result: { profile: profile?.name } },
+        { name: "context-compress", planned: true, result: { mode: options.contextMode, level: profile?.compressionLevel } },
+        { name: "fewshot-retrieve", planned: true, result: { maxExamples: options.maxExamples } },
+        { name: "task-plan", planned: true, result: { kind, nodes: dag.nodeCount } },
+        { name: "generate", planned: true, result: { mode: options.multiAgent ? "multi-agent" : "single-pass" } },
+        { name: "hydrate", planned: true, result: {} },
+        { name: "validate", planned: true, result: { enabled: options.validate } },
+      ],
+    },
+    plan: {
+      task,
+      kind,
+      profile: profile?.name,
+      dag,
+      estimatedDuration: estimateDuration(profile, options),
+      command: `opl boost generate "${task}"${options.multiAgent ? " --multi-agent" : ""}`,
+    },
+    report: {
+      summary: `📋 Dry-run: generaría un @kind(${kind}) usando perfil ${profile?.name || "unknown"}`,
+      duration: "N/A (dry-run)",
+    },
+  }
+}
+
+function estimateDuration(profile, options) {
+  const baseTime = profile?.name === "small" ? 30 : profile?.name === "large" ? 8 : 15
+  const agentMultiplier = options.multiAgent ? 2.5 : 1
+  return `${Math.round(baseTime * agentMultiplier)}s (estimado)`
+}
+
+// ──────────────────────────────────────────────
+// Utilidades
+// ──────────────────────────────────────────────
+
+/**
+ * Código de conveniencia para generar y mostrar resultado.
+ * Útil para CLI.
+ *
+ * @param {string} task
+ * @param {object} options
+ * @returns {Promise<string>} Código generado
+ */
+export async function generateCode(task, options = {}) {
+  const result = await boost(task, options)
+  return result.code
+}