openprompt-lang 1.2.6 → 1.3.0

package/src/commands/workflow/epic-cli.js

@@ -0,0 +1,192 @@
+// @kind(module)
+// @contract(in: args:object -> out: void, sideEffect: gestiona épicas vía CLI)
+// @limit(lines: 180)
+// @deps(@external: [chalk, ../../core/workflow/epic-manager])
+
+/**
+ * Comandos CLI para gestión de épicas.
+ *
+ * Uso:
+ *   npx openPrompt-Lang epic create --title "Sistema de Reportes" --desc "..."
+ *   npx openPrompt-Lang epic list
+ *   npx openPrompt-Lang epic show EPIC-001
+ *   npx openPrompt-Lang epic close EPIC-001
+ */
+
+import chalk from "chalk"
+import {
+  createEpic,
+  listEpics,
+  updateEpic,
+  addTicketsToEpic,
+  generateStatusReport,
+} from "../../core/workflow/epic-manager.js"
+
+/**
+ * Crea una nueva épica desde CLI.
+ *
+ * @param {object} options
+ * @param {string} options.title - Título de la épica
+ * @param {string} options.desc - Descripción detallada
+ * @param {string} [options.domain] - Dominio
+ * @param {boolean} [options.noAutoTickets] - No generar tickets automáticamente
+ */
+export async function epicCreate(options) {
+  if (!options.title) {
+    console.log(chalk.red('\n❌ El título es requerido. Usa: --title "..."'))
+    return
+  }
+
+  console.log(chalk.cyan(`\n📦 Creando épica: ${options.title}`))
+  console.log(chalk.gray("   Analizando descripción para generar tickets...\n"))
+
+  try {
+    const epic = createEpic(options.title, options.desc || "", {
+      autoGenerateTickets: !options.noAutoTickets,
+      domain: options.domain,
+    })
+
+    console.log(chalk.green(`✅ Épica creada: ${epic.id}`))
+    console.log(chalk.cyan(`   Título: ${epic.title}`))
+    console.log(chalk.cyan(`   Tickets generados: ${epic.tickets.length}`))
+    console.log(chalk.cyan(`   Días estimados: ${epic.metrics?.estimatedDays || "?"}`))
+    console.log(chalk.cyan(`   Estado: ${epic.status}`))
+    console.log("")
+
+    if (epic.tickets.length > 0) {
+      console.log(chalk.gray("   Tickets creados:"))
+      for (const ticket of epic.tickets) {
+        console.log(chalk.gray(`     • ${ticket.id}: ${ticket.title}`))
+      }
+      console.log("")
+    }
+
+    console.log(chalk.cyan("   Siguientes pasos:"))
+    console.log(chalk.gray("     1. Revisa los tickets creados"))
+    console.log(chalk.gray("     2. Asigna a un sprint: npx openPrompt-Lang sprint create"))
+    console.log(chalk.gray("     3. Comienza con: npx openPrompt-Lang workflow select"))
+    console.log("")
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`))
+  }
+}
+
+/**
+ * Lista las épicas.
+ *
+ * @param {object} options
+ * @param {string} [options.status] - Filtrar por estado
+ * @param {string} [options.domain] - Filtrar por dominio
+ */
+export async function epicList(options) {
+  try {
+    const epics = listEpics({
+      status: options.status,
+      domain: options.domain,
+    })
+
+    if (epics.length === 0) {
+      console.log(chalk.yellow("\n📭 No hay épicas.\n"))
+      console.log(chalk.gray("   Crea una con:"))
+      console.log(chalk.cyan('   npx openPrompt-Lang epic create --title "..." --desc "..."\n'))
+      return
+    }
+
+    console.log(chalk.cyan(`\n📋 Épicas (${epics.length})\n`))
+    console.log(
+      chalk.gray(
+        `  ${"ID".padEnd(12)}${"Título".padEnd(35)}${"Estado".padEnd(12)}${"Tickets".padEnd(10)}Progreso`
+      )
+    )
+    console.log(chalk.gray(`  ${"─".repeat(75)}`))
+
+    for (const epic of epics) {
+      const statusColor =
+        { planning: chalk.blue, active: chalk.green, done: chalk.gray, cancelled: chalk.red }[
+          epic.status
+        ] || chalk.white
+
+      const total = epic.metrics?.totalTickets || 0
+      const done = epic.metrics?.doneTickets || 0
+      const progress = total > 0 ? `${done}/${total}` : "0/0"
+      const title = epic.title.length > 32 ? `${epic.title.slice(0, 29)}...` : epic.title
+
+      console.log(
+        `  ${epic.id.padEnd(12)}${title.padEnd(35)}${statusColor(epic.status.padEnd(12))}${progress.padEnd(10)}${total > 0 ? `${Math.round((done / total) * 100)}%` : "—"}`
+      )
+    }
+    console.log("")
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`))
+  }
+}
+
+/**
+ * Muestra detalle de una épica.
+ *
+ * @param {string} epicId
+ */
+export async function epicShow(epicId) {
+  try {
+    const epics = listEpics()
+    const epic = epics.find((e) => e.id === epicId)
+
+    if (!epic) {
+      console.log(chalk.red(`\n❌ Épica no encontrada: ${epicId}\n`))
+      return
+    }
+
+    console.log(chalk.cyan(`\n📦 ${epic.id}: ${epic.title}\n`))
+    console.log(chalk.gray(`   Estado:     ${epic.status}`))
+    console.log(
+      chalk.gray(
+        `   Creada:     ${epic.created ? new Date(epic.created).toLocaleDateString() : "—"}`
+      )
+    )
+    console.log(chalk.gray(`   Dominio:    ${epic.domain || "shared"}`))
+    console.log(chalk.gray(`   Días est.:  ${epic.metrics?.estimatedDays || "?"}`))
+    console.log("")
+    console.log(chalk.gray(`   ${epic.description || "Sin descripción"}`))
+    console.log("")
+
+    if (epic.tickets && epic.tickets.length > 0) {
+      console.log(chalk.cyan(`   Tickets (${epic.tickets.length}):`))
+      for (const ticket of epic.tickets) {
+        const statusIcon = ticket.status === "done" || ticket.status === "fixed" ? "✅" : "📌"
+        console.log(`     ${statusIcon} ${ticket.id}: ${ticket.title} (${ticket.status})`)
+      }
+      console.log("")
+    }
+
+    if (epic.sprints && epic.sprints.length > 0) {
+      console.log(chalk.cyan(`   Sprints: ${epic.sprints.join(", ")}`))
+      console.log("")
+    }
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`))
+  }
+}
+
+/**
+ * Cierra una épica.
+ *
+ * @param {string} epicId
+ * @param {object} options
+ * @param {string} [options.status="done"]
+ */
+export async function epicClose(epicId, options = {}) {
+  try {
+    const newStatus = options.status || "done"
+    const epic = updateEpic(epicId, { status: newStatus })
+    console.log(chalk.green(`\n✅ Épica ${epicId} marcada como "${newStatus}"\n`))
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`))
+  }
+}
+
+/**
+ * Muestra el reporte de estado del proyecto.
+ */
+export async function epicStatus() {
+  console.log(generateStatusReport())
+}

package/src/commands/workflow/select.js

@@ -0,0 +1,146 @@
+// @kind(module)
+// @contract(in: description:string, options:object -> out: void, sideEffect: muestra workflow seleccionado)
+// @limit(lines: 150)
+// @deps(@external: [chalk, ../../core/workflow/selector, ../../core/workflow/epic-manager])
+
+/**
+ * CLI para selección inteligente de workflows.
+ *
+ * Analiza la descripción de la tarea y muestra el workflow más adecuado,
+ * incluyendo pasos, detección de conflictos y requerimientos de gates.
+ *
+ * Uso:
+ *   npx openPrompt-Lang workflow select "Implementar un sistema de reportes"
+ *   npx openPrompt-Lang workflow select "Arreglar bug en login" --strict
+ *   npx openPrompt-Lang workflow select --list
+ */
+
+import chalk from "chalk"
+import {
+  selectWorkflow,
+  listWorkflows,
+  formatWorkflowSummary,
+} from "../../core/workflow/selector.js"
+import { detectPlanAdjustments, generateStatusReport } from "../../core/workflow/epic-manager.js"
+
+/**
+ * Ejecuta el comando de selección de workflow.
+ *
+ * @param {string} description - Descripción de la tarea
+ * @param {object} [options]
+ * @param {boolean} [options.list] - Listar workflows disponibles
+ * @param {boolean} [options.strict] - Modo estricto: no permite omisión de gates
+ * @param {boolean} [options.json] - Salida en JSON
+ * @param {boolean} [options.status] - Mostrar reporte de estado del proyecto
+ */
+export async function workflowSelect(description, options = {}) {
+  if (options.list) {
+    await listAvailableWorkflows()
+    return
+  }
+
+  if (options.status) {
+    console.log(generateStatusReport())
+    return
+  }
+
+  if (!description) {
+    console.log(chalk.yellow("\n⚠️  Describe la tarea para seleccionar el workflow:"))
+    console.log(chalk.cyan('    npx openPrompt-Lang workflow select "Implementar login con OAuth"'))
+    console.log(chalk.gray("\n  O usa --list para ver los workflows disponibles."))
+    console.log(chalk.gray("  O usa --status para ver el estado del proyecto.\n"))
+    return
+  }
+
+  // Seleccionar workflow
+  console.log(chalk.cyan("\n🔍 Analizando tarea..."))
+  console.log(chalk.gray(`   "${description}"\n`))
+
+  const match = selectWorkflow(description)
+
+  // Detectar ajustes de plan si hay épicas
+  let adjustments = []
+  try {
+    adjustments = detectPlanAdjustments(match.label || description, description)
+  } catch {
+    // El módulo de épicas puede no estar disponible
+  }
+
+  // Mostrar resultado
+  if (options.json) {
+    console.log(JSON.stringify(match, null, 2))
+    return
+  }
+
+  console.log(formatWorkflowSummary(match))
+
+  // Mostrar alertas de ajustes de plan
+  if (adjustments.length > 0) {
+    console.log(chalk.yellow("\n⚠️  Ajustes de plan detectados:\n"))
+    for (const adj of adjustments) {
+      const color =
+        adj.overlapRatio > 60 ? chalk.red : adj.overlapRatio > 40 ? chalk.yellow : chalk.cyan
+      console.log(color(`   ${adj.epicId}: "${adj.title}" — ${adj.overlapRatio}% superposición`))
+      console.log(chalk.gray(`   → ${adj.suggestion}`))
+      console.log("")
+    }
+  }
+
+  // Mostrar próximos pasos
+  console.log(chalk.cyan("   Próximos pasos:"))
+  const firstSteps = match.steps.slice(0, 3)
+  for (const step of firstSteps) {
+    console.log(chalk.gray(`      ${step.step}. ${step.action} — ${step.purpose}`))
+  }
+  console.log(chalk.gray(`      ... y ${Math.max(0, match.steps.length - 3)} paso(s) más`))
+
+  // Advertencia de gates si modo estricto
+  if (options.strict) {
+    const gates = []
+    if (match.requiresTicket) gates.push("ticket_created")
+    if (match.requiresDocs) gates.push("docs_updated")
+    if (match.requiresPlan) gates.push("plan_approved")
+
+    if (gates.length > 0) {
+      console.log(chalk.yellow(`\n   🚧 Gates requeridos (strict mode): ${gates.join(", ")}`))
+      console.log(chalk.gray("   Estos gates deben cumplirse antes de cerrar la tarea.\n"))
+    }
+  } else {
+    console.log("")
+  }
+
+  // Registrar workflow seleccionado en sesión si existe
+  try {
+    const { join } = await import("path")
+    const { existsSync, readFileSync, writeFileSync } = await import("fs")
+    const sessionPath = join(process.cwd(), ".opencode", "work-context", "SESSION.json")
+    if (existsSync(sessionPath)) {
+      const session = JSON.parse(readFileSync(sessionPath, "utf-8"))
+      session.selectedWorkflow = match.workflowId
+      session.selectedWorkflowLabel = match.label
+      session.selectedWorkflowSteps = match.steps.length
+      writeFileSync(sessionPath, JSON.stringify(session, null, 2), "utf-8")
+    }
+  } catch {
+    // Ignorar si no hay sesión
+  }
+}
+
+/**
+ * Lista todos los workflows disponibles.
+ */
+async function listAvailableWorkflows() {
+  const workflows = listWorkflows()
+
+  console.log(chalk.cyan("\n📋 Workflows Disponibles\n"))
+  console.log(chalk.gray(`  ${"ID".padEnd(20)}${"Nombre".padEnd(30)}${"Triggers".padEnd(10)}Pasos`))
+  console.log(chalk.gray(`  ${"─".repeat(70)}`))
+
+  for (const wf of workflows) {
+    console.log(
+      `  ${wf.id.padEnd(20)}${chalk.white(wf.label.padEnd(30))}${String(wf.triggerCount).padEnd(10)}${wf.stepCount}`
+    )
+  }
+
+  console.log(chalk.gray("\n  Usa: npx openPrompt-Lang workflow select <descripción>\n"))
+}

package/src/commands/workflow/specification/index.js

@@ -8,6 +8,7 @@ import { ensureSchema } from "../../../persistence/sqlite/schema.js"
 import { runMigrations } from "../../../persistence/sqlite/migrations.js"
 import { getMetadata, setMetadata } from "../../../persistence/sqlite/queries.js"
 import { executeTransition, canTransition } from "../../../core/workflow/transitions.js"
+import { syncWorkflowPhase } from "../../../mcp-shared-state.js"
 import { getWizardResponses } from "../../../wizard/orchestrator.js"
 import { generateDocs } from "../../../docgen/generator.js"
 import {
@@ -103,6 +104,9 @@ export async function specification(options = {}) {
   executeTransition(ctx.currentPhase, "SPECIFICATION", ctx)
   setMetadata(db, "workflow_phase", "SPECIFICATION")
 
+  // Sincronizar con MCP shared state: SPECIFICATION → modo plan
+  syncWorkflowPhase("SPECIFICATION")
+
   conn.close()
 
   console.log(chalk.green(`\n✅ Specification completada para: ${projectId}`))

package/src/commands/workflow/sprint-cli.js

@@ -0,0 +1,174 @@
+// @kind(module)
+// @contract(in: args:object -> out: void, sideEffect: gestiona sprints vía CLI)
+// @limit(lines: 160)
+// @deps(@external: [chalk, ../../core/workflow/epic-manager])
+
+/**
+ * Comandos CLI para gestión de sprints.
+ *
+ * Uso:
+ *   npx openPrompt-Lang sprint create "Sprint 1: Core" --goal "Implementar auth"
+ *   npx openPrompt-Lang sprint plan SPRINT-001 --capacity 8
+ *   npx openPrompt-Lang sprint list
+ *   npx openPrompt-Lang sprint close SPRINT-001
+ */
+
+import chalk from "chalk"
+import {
+  createSprint,
+  listSprints,
+  updateSprint,
+  planSprint,
+} from "../../core/workflow/epic-manager.js"
+
+/**
+ * Crea un nuevo sprint.
+ *
+ * @param {string} name - Nombre del sprint
+ * @param {object} options
+ * @param {string} options.goal - Objetivo del sprint
+ * @param {number} [options.duration] - Duración en días (default: 14)
+ * @param {string} [options.startDate] - Fecha inicio
+ */
+export async function sprintCreate(name, options = {}) {
+  if (!name) {
+    console.log(chalk.red("\n❌ El nombre del sprint es requerido."))
+    return
+  }
+
+  if (!options.goal) {
+    console.log(chalk.red('\n❌ El objetivo del sprint es requerido. Usa: --goal "..."'))
+    return
+  }
+
+  try {
+    const sprint = createSprint(name, options.goal, {
+      startDate: options.startDate,
+      durationDays: options.duration || 14,
+    })
+
+    console.log(chalk.green(`\n✅ Sprint creado: ${sprint.id}`))
+    console.log(chalk.cyan(`   Nombre:  ${sprint.name}`))
+    console.log(chalk.cyan(`   Objetivo: ${sprint.goal}`))
+    console.log(chalk.cyan(`   Duración: ${sprint.startDate} → ${sprint.endDate}`))
+    console.log("")
+
+    console.log(chalk.cyan("   Siguientes pasos:"))
+    console.log(chalk.gray(`     1. Planificar: npx openPrompt-Lang sprint plan ${sprint.id}`))
+    console.log(chalk.gray("     2. Asignar épicas existentes"))
+    console.log("")
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`))
+  }
+}
+
+/**
+ * Lista los sprints.
+ *
+ * @param {object} options
+ * @param {string} [options.status] - Filtrar por estado
+ */
+export async function sprintList(options = {}) {
+  try {
+    const sprints = listSprints({ status: options.status })
+
+    if (sprints.length === 0) {
+      console.log(chalk.yellow("\n📭 No hay sprints.\n"))
+      console.log(
+        chalk.gray('   Crea uno con: npx openPrompt-Lang sprint create "Sprint 1" --goal "..."\n')
+      )
+      return
+    }
+
+    console.log(chalk.cyan(`\n📋 Sprints (${sprints.length})\n`))
+    console.log(
+      chalk.gray(
+        `  ${"ID".padEnd(14)}${"Nombre".padEnd(30)}${"Estado".padEnd(12)}${"Rango".padEnd(24)}Progreso`
+      )
+    )
+    console.log(chalk.gray(`  ${"─".repeat(85)}`))
+
+    for (const sprint of sprints) {
+      const statusColor =
+        { planning: chalk.blue, active: chalk.green, completed: chalk.gray }[sprint.status] ||
+        chalk.white
+
+      const total = sprint.metrics?.totalTickets || 0
+      const done = sprint.metrics?.doneTickets || 0
+      const range = `${sprint.startDate || "?"} → ${sprint.endDate || "?"}`
+      const name = sprint.name.length > 27 ? `${sprint.name.slice(0, 24)}...` : sprint.name
+
+      console.log(
+        `  ${sprint.id.padEnd(14)}${name.padEnd(30)}${statusColor(sprint.status.padEnd(12))}${range.padEnd(24)}${total > 0 ? `${done}/${total}` : "—"}`
+      )
+    }
+    console.log("")
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`))
+  }
+}
+
+/**
+ * Planifica un sprint automáticamente.
+ *
+ * @param {string} sprintId
+ * @param {object} options
+ * @param {number} [options.capacity=10]
+ */
+export async function sprintPlan(sprintId, options = {}) {
+  if (!sprintId) {
+    console.log(chalk.red("\n❌ ID del sprint requerido."))
+    return
+  }
+
+  try {
+    console.log(chalk.cyan(`\n📋 Planificando ${sprintId}...\n`))
+
+    const sprint = planSprint(sprintId, {
+      capacity: options.capacity || 10,
+    })
+
+    console.log(chalk.green(`✅ Sprint planificado: ${sprint.name}`))
+    console.log(chalk.cyan(`   Tickets asignados: ${sprint.ticketIds.length}`))
+    console.log(chalk.cyan(`   Épicas cubiertas: ${sprint.epicIds.length}`))
+    console.log("")
+
+    if (sprint.ticketIds.length > 0) {
+      console.log(chalk.gray("   Tickets en este sprint:"))
+      for (const ticketId of sprint.ticketIds) {
+        console.log(chalk.gray(`     • ${ticketId}`))
+      }
+      console.log("")
+    }
+
+    // Activar sprint
+    updateSprint(sprintId, { status: "active" })
+    console.log(chalk.green(`   ✅ Sprint activado. ¡A trabajar!\n`))
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`))
+  }
+}
+
+/**
+ * Cierra un sprint.
+ *
+ * @param {string} sprintId
+ */
+export async function sprintClose(sprintId) {
+  if (!sprintId) {
+    console.log(chalk.red("\n❌ ID del sprint requerido."))
+    return
+  }
+
+  try {
+    const sprint = updateSprint(sprintId, { status: "completed" })
+    console.log(chalk.green(`\n✅ Sprint ${sprintId} completado.`))
+    console.log(
+      chalk.cyan(
+        `   ${sprint.metrics?.doneTickets || 0}/${sprint.metrics?.totalTickets || 0} tickets completados.\n`
+      )
+    )
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`))
+  }
+}

package/src/core/engine/sandbox.js

@@ -89,10 +89,12 @@ async function executeLocalFast(payload, cwd, startAt, startTime) {
     const timeout = constraints.timeoutMs || 30000
     let isTimeout = false
 
+    // shell: false — args ya se dividen manualmente (bin + args).
+    // Esto previene command injection si el comando contiene caracteres especiales.
     const child = spawn(bin, args, {
       cwd,
-      shell: true,
-      env: process.env, // Permitir entorno actual para local-fast
+      shell: false,
+      env: process.env,
     })
 
     const timeoutId = setTimeout(() => {
@@ -210,8 +212,10 @@ async function executeDockerEphemeral(payload, cwd, startAt, startTime) {
     let stderrRaw = ""
     let isTimeout = false
 
+    // shell: false — dockerArgs ya se parsean manualmente como array.
+    // Los comandos internos de docker se ejecutan via "sh -c '<cmd>'".
     const child = spawn("docker", dockerArgs, {
-      shell: true, // Necesario en Windows, pero útil para que interprete bien las comillas en los argumentos
+      shell: false,
     })
 
     const timeoutId = setTimeout(() => {