openprompt-lang 1.2.7 → 1.3.0

package/src/core/workflow/gates.js

@@ -1,8 +1,11 @@
 // @kind(module)
 // @contract(in: gateName:string, context:object -> out: {passed:boolean, reason:string} @error: WorkflowError)
-// @limit(lines: 120)
+// @limit(lines: 340)
 // @pattern(provider)
 
+import { join } from "path"
+import { existsSync, readFileSync, readdirSync, statSync } from "fs"
+
 /**
  * Módulo de gates de workflow.
  *
@@ -75,6 +78,182 @@ const GATES = Object.freeze({
     message: "El proyecto debe existir en la base de datos (opl project init o wizard)",
     description: "El proyecto debe estar registrado en SQLite",
   },
+
+  // ─── Nuevos gates v2 (workflow inteligente) ─────────────────────────────────
+
+  docs_updated: {
+    requires: "docs_updated",
+    message: "Debes actualizar la documentación antes de cerrar. Ejecuta: opl doc flow/framework",
+    description: "La documentación debe estar actualizada antes de cerrar la sesión",
+    customCheck: (ctx) => {
+      // Verificar que existe documentación reciente
+      const docsDir = join(process.cwd(), "docs")
+      let hasRecentDocs = false
+      try {
+        if (existsSync(docsDir)) {
+          const files = readdirSync(docsDir).filter((f) => f.endsWith(".md") || f.endsWith(".mdx"))
+          const fourHoursAgo = Date.now() - 4 * 60 * 60 * 1000
+          for (const f of files) {
+            const stat = statSync(join(docsDir, f))
+            if (stat.mtimeMs > fourHoursAgo) {
+              hasRecentDocs = true
+              break
+            }
+          }
+        }
+      } catch {
+        // Si no se puede verificar, pasar con advertencia
+      }
+
+      if (hasRecentDocs || ctx.flags?.docs_updated) {
+        return { passed: true, reason: "Documentación actualizada verificada" }
+      }
+
+      const sessionPath = join(process.cwd(), ".opencode", "work-context", "SESSION.json")
+      let hasSessionDocs = false
+      try {
+        if (existsSync(sessionPath)) {
+          const session = JSON.parse(readFileSync(sessionPath, "utf-8"))
+          hasSessionDocs = !!session.docGenerated
+        }
+      } catch {
+        // Ignorar
+      }
+
+      if (hasSessionDocs) {
+        return { passed: true, reason: "Documentación de sesión generada" }
+      }
+
+      return {
+        passed: false,
+        reason:
+          "No se detectaron documentos actualizados recientemente. Debes generar la documentación antes de cerrar.",
+      }
+    },
+  },
+
+  ticket_created: {
+    requires: "ticket_created",
+    message:
+      'Debes crear un ticket antes de implementar. Ejecuta: npx openPrompt-Lang ticket create --title "..."',
+    description: "Todo cambio debe tener un ticket asociado antes de implementar",
+    customCheck: (ctx) => {
+      const bugsDir = join(process.cwd(), ".opencode", "bugs")
+      let hasOpenTicket = false
+      let ticketCount = 0
+      try {
+        if (existsSync(bugsDir)) {
+          const files = readdirSync(bugsDir).filter((f) => f.endsWith(".md"))
+          ticketCount = files.length
+          for (const f of files) {
+            const content = readFileSync(join(bugsDir, f), "utf-8")
+            const statusMatch = content.match(/\*\*Estado\*\*\s+\|\s+(\w+)/)
+            if (statusMatch && ["open", "wip"].includes(statusMatch[1])) {
+              hasOpenTicket = true
+              break
+            }
+          }
+        }
+      } catch {
+        // Si no se puede leer, asumir que no hay tickets
+      }
+
+      if (hasOpenTicket || ctx.flags?.ticket_created) {
+        return {
+          passed: true,
+          reason: `Ticket existente verificado (${ticketCount} ticket(s) en total)`,
+        }
+      }
+
+      return {
+        passed: false,
+        reason: "No hay tickets abiertos. Todo cambio debe comenzar con un ticket.",
+      }
+    },
+  },
+
+  plan_approved: {
+    requires: "plan_approved",
+    message: "Debes tener un plan aprobado antes de implementar. Ejecuta: work_context_plan",
+    description: "Implementación requiere plan aprobado",
+    customCheck: (ctx) => {
+      const plansDir = join(process.cwd(), ".opencode", "work-context", "PLANS")
+      let hasPlan = false
+      try {
+        if (existsSync(plansDir)) {
+          const files = readdirSync(plansDir).filter((f) => f.endsWith(".md"))
+          // Buscar plan aprobado (últimas 24h)
+          const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000
+          for (const f of files) {
+            const stat = statSync(join(plansDir, f))
+            if (stat.mtimeMs > oneDayAgo) {
+              const content = readFileSync(join(plansDir, f), "utf-8")
+              if (
+                content.includes("## Plan") ||
+                content.toLowerCase().includes("work_context_plan")
+              ) {
+                hasPlan = true
+                break
+              }
+            }
+          }
+          // Si no hay plan reciente, aceptar cualquier plan
+          if (!hasPlan && files.length > 0) {
+            hasPlan = true
+          }
+        }
+      } catch {
+        // Si no se puede leer, pasar con advertencia
+      }
+
+      if (hasPlan || ctx.flags?.plan_approved) {
+        return { passed: true, reason: "Plan de trabajo verificado" }
+      }
+
+      return {
+        passed: false,
+        reason:
+          "No se encontró un plan de trabajo. Usa work_context_plan para crear uno antes de implementar.",
+      }
+    },
+  },
+
+  workflow_selected: {
+    requires: "workflow_selected",
+    message:
+      "Debes seleccionar un workflow primero. Describe la tarea con: npx openPrompt-Lang workflow select <descripción>",
+    description: "Requiere que se haya seleccionado un workflow automáticamente",
+    customCheck: (ctx) => {
+      if (ctx.flags?.workflow_selected) {
+        return {
+          passed: true,
+          reason: `Workflow seleccionado: ${ctx.flags?.selected_workflow || "desconocido"}`,
+        }
+      }
+
+      // Verificar si hay workflow seleccionado en sesión
+      const sessionPath = join(process.cwd(), ".opencode", "work-context", "SESSION.json")
+      try {
+        if (existsSync(sessionPath)) {
+          const session = JSON.parse(readFileSync(sessionPath, "utf-8"))
+          if (session.selectedWorkflow) {
+            return {
+              passed: true,
+              reason: `Workflow seleccionado en sesión: ${session.selectedWorkflow}`,
+            }
+          }
+        }
+      } catch {
+        // Ignorar
+      }
+
+      return {
+        passed: false,
+        reason:
+          "No hay workflow seleccionado. Usa el selector automático para elegir el workflow adecuado.",
+      }
+    },
+  },
 })
 
 /**