openprompt-lang 1.2.7 → 1.3.0

package/src/core/workflow/epic-manager.js

@@ -0,0 +1,845 @@
+// @kind(module)
+// @contract(in: action:string, data:object -> out: object @error: EpicManagerError)
+// @limit(lines: 820)
+// @pattern(provider)
+// @deps(@external: [path, fs, ../../core/workflow/selector])
+
+/**
+ * Gestor de épicas, tickets agrupados y sprints.
+ *
+ * Proporciona una capa de organización ágil sobre el sistema de tickets existente.
+ * Almacena épicas y sprints como archivos en .opencode/epics/ y .opencode/sprints/.
+ *
+ * Funcionalidades:
+ * - Crear épicas desde descripciones de features
+ * - Auto-generar tickets dentro de épicas (análisis de la descripción)
+ * - Organizar tickets en sprints
+ * - Trackear progreso de épicas y sprints
+ * - Ajustar planes existentes cuando llega nuevo trabajo
+ *
+ * Uso:
+ *   import { createEpic, listEpics, createSprint, planSprint } from './epic-manager.js';
+ *   const epic = createEpic("Sistema de reportes", "Implementar módulo de reportes con gráficos y exportación");
+ *   console.log(epic.tickets); // [{title, status}, ...]
+ */
+
+import { readFileSync, existsSync, writeFileSync, readdirSync, mkdirSync } from "fs"
+import { join } from "path"
+
+const EPICS_DIR = join(process.cwd(), ".opencode", "epics")
+const SPRINTS_DIR = join(process.cwd(), ".opencode", "sprints")
+
+/**
+ * @typedef {object} Epic
+ * @property {string} id - ID único de la épica (EPIC-001)
+ * @property {string} title - Título corto
+ * @property {string} description - Descripción completa
+ * @property {string} status - Estado: planning | active | done | cancelled
+ * @property {string} created - Fecha ISO
+ * @property {string} [started] - Fecha ISO de inicio
+ * @property {string} [completed] - Fecha ISO de completado
+ * @property {Array<{id:string, title:string, status:string, sprintId?:string}>} tickets - Tickets asociados
+ * @property {string[]} [sprints] - IDs de sprints que cubren esta épica
+ * @property {string} [domain] - Dominio asociado
+ * @property {object} [metrics] - Métricas: totalTickets, doneTickets, estimatedDays
+ */
+
+/**
+ * @typedef {object} Sprint
+ * @property {string} id - ID del sprint (SPRINT-001)
+ * @property {string} name - Nombre del sprint (ej: "Sprint 1: Core")
+ * @property {string} goal - Objetivo del sprint
+ * @property {string} status - Estado: planning | active | completed
+ * @property {string} startDate - Fecha ISO inicio
+ * @property {string} endDate - Fecha ISO fin
+ * @property {string[]} ticketIds - IDs de tickets asignados
+ * @property {string[]} epicIds - IDs de épicas cubiertas
+ * @property {object} [metrics] - Métricas: totalTickets, doneTickets, velocity
+ */
+
+// ─── Error ──────────────────────────────────────────────────────────────────────
+
+export class EpicManagerError extends Error {
+  /**
+   * @param {string} message
+   * @param {object} [details]
+   */
+  constructor(message, details = {}) {
+    super(message)
+    this.name = "EpicManagerError"
+    this.details = details
+  }
+}
+
+// ─── Utilidades ──────────────────────────────────────────────────────────────────
+
+function ensureDirs() {
+  mkdirSync(EPICS_DIR, { recursive: true })
+  mkdirSync(SPRINTS_DIR, { recursive: true })
+}
+
+function now() {
+  return new Date().toISOString()
+}
+
+function shortDate() {
+  return new Date().toISOString().split("T")[0]
+}
+
+function slug(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9áéíóúüñ\s-]/g, "")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .slice(0, 50)
+    .replace(/^-|-$/g, "")
+}
+
+function generateId(prefix, existing) {
+  const nums = existing
+    .map((e) => e.id)
+    .filter((id) => id && id.startsWith(prefix))
+    .map((id) => parseInt(id.replace(`${prefix}-`, ""), 10))
+    .filter((n) => !isNaN(n))
+  const max = nums.length > 0 ? Math.max(...nums) : 0
+  return `${prefix}-${String(max + 1).padStart(3, "0")}`
+}
+
+// ─── Persistencia de Épicas ──────────────────────────────────────────────────────
+
+/**
+ * Lee todas las épicas desde el directorio de archivos.
+ *
+ * @returns {Epic[]}
+ */
+function readAllEpics() {
+  if (!existsSync(EPICS_DIR)) return []
+  const files = readdirSync(EPICS_DIR).filter((f) => f.endsWith(".json"))
+  const epics = []
+  for (const f of files) {
+    try {
+      const epic = JSON.parse(readFileSync(join(EPICS_DIR, f), "utf-8"))
+      epics.push(epic)
+    } catch {
+      // Saltar archivos corruptos
+    }
+  }
+  return epics
+}
+
+/**
+ * Guarda una épica en disco.
+ *
+ * @param {Epic} epic
+ */
+function writeEpic(epic) {
+  ensureDirs()
+  const filename = `${epic.id}-${slug(epic.title)}.json`
+  writeFileSync(join(EPICS_DIR, filename), JSON.stringify(epic, null, 2), "utf-8")
+}
+
+/**
+ * Lee una épica por ID.
+ *
+ * @param {string} id
+ * @returns {Epic|null}
+ */
+function readEpic(id) {
+  if (!existsSync(EPICS_DIR)) return null
+  const files = readdirSync(EPICS_DIR).filter((f) => f.startsWith(id))
+  for (const f of files) {
+    try {
+      return JSON.parse(readFileSync(join(EPICS_DIR, f), "utf-8"))
+    } catch {
+      return null
+    }
+  }
+  return null
+}
+
+// ─── Persistencia de Sprints ─────────────────────────────────────────────────────
+
+/**
+ * Lee todos los sprints desde el directorio.
+ *
+ * @returns {Sprint[]}
+ */
+function readAllSprints() {
+  if (!existsSync(SPRINTS_DIR)) return []
+  const files = readdirSync(SPRINTS_DIR).filter((f) => f.endsWith(".json"))
+  const sprints = []
+  for (const f of files) {
+    try {
+      const sprint = JSON.parse(readFileSync(join(SPRINTS_DIR, f), "utf-8"))
+      sprints.push(sprint)
+    } catch {
+      // Saltar archivos corruptos
+    }
+  }
+  return sprints
+}
+
+/**
+ * Guarda un sprint en disco.
+ *
+ * @param {Sprint} sprint
+ */
+function writeSprint(sprint) {
+  ensureDirs()
+  const filename = `${sprint.id}-${slug(sprint.name)}.json`
+  writeFileSync(join(SPRINTS_DIR, filename), JSON.stringify(sprint, null, 2), "utf-8")
+}
+
+// ─── Tickets helper ──────────────────────────────────────────────────────────────
+
+/**
+ * Crea un ticket de bug usando el sistema existente de archivos.
+ * Devuelve el ID del ticket creado o null si falla.
+ *
+ * @param {string} title
+ * @param {string} description
+ * @param {string} domain
+ * @returns {string|null}
+ */
+function createBugTicket(title, description, domain = "shared") {
+  try {
+    const bugsDir = join(process.cwd(), ".opencode", "bugs")
+    mkdirSync(bugsDir, { recursive: true })
+
+    // Leer tickets existentes para generar ID
+    let existing = []
+    if (existsSync(bugsDir)) {
+      const files = readdirSync(bugsDir).filter((f) => f.endsWith(".md"))
+      existing = files.map((f) => {
+        // Extract full ID (BUG-NNN) from filename like "BUG-001-sistema-reportes.md"
+        const match = f.match(/^(BUG-\d+)/)
+        return { id: match ? match[1] : f.split("-")[0] }
+      })
+    }
+
+    const id = generateId("BUG", existing)
+    const nowDate = shortDate()
+    const ticketSlug = slug(title)
+    const filename = `${id}-${ticketSlug}.md`
+
+    const content = `# ${id} — ${title}
+
+| Campo | Valor |
+|-------|-------|
+| **ID** | ${id} |
+| **Título** | ${title} |
+| **Severidad** | medium |
+| **Estado** | open |
+| **Proyecto** | ${loadProjectName() || "unknown"} |
+| **Dominio** | ${domain} |
+| **Fecha** | ${nowDate} |
+| **Origen** | epic-auto |
+
+## Descripción
+
+${description}
+
+## Tareas
+
+- [ ] Implementar funcionalidad
+- [ ] Escribir tests
+- [ ] Actualizar documentación
+
+## Notas
+
+_Creado automáticamente desde épica_
+`
+
+    writeFileSync(join(bugsDir, filename), content, "utf-8")
+    return id
+  } catch (err) {
+    console.error(`[epic-manager] Error creando ticket: ${err.message}`)
+    return null
+  }
+}
+
+/**
+ * Carga el nombre del proyecto desde prompt-lang.json.
+ *
+ * @returns {string|null}
+ */
+function loadProjectName() {
+  try {
+    const configPath = join(process.cwd(), "prompt-lang.json")
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"))
+      return config.name || null
+    }
+  } catch {
+    // Ignorar
+  }
+  return null
+}
+
+// ─── Análisis de descripción para generar tickets ────────────────────────────────
+
+/**
+ * Analiza una descripción de épica y extrae tickets sugeridos.
+ * Busca patrones como listas, verbos de acción, subtítulos.
+ *
+ * @param {string} description
+ * @returns {Array<{title:string, description:string}>}
+ */
+function extractTicketsFromDescription(description) {
+  const tickets = []
+  const lines = description.split("\n")
+
+  let currentSection = ""
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    // Detectar subtítulos como secciones de tickets
+    const subtitleMatch = trimmed.match(/^#{1,3}\s+(.+)/)
+    if (subtitleMatch) {
+      currentSection = subtitleMatch[1]
+      tickets.push({
+        title: currentSection,
+        description: `Implementar: ${currentSection}`,
+      })
+      continue
+    }
+
+    // Detectar ítems de lista como tickets
+    const listItemMatch = trimmed.match(/^[-*+]\s+(.+)/)
+    if (listItemMatch) {
+      const item = listItemMatch[1]
+      // Saltar items de metadatos o sin contenido real
+      if (item.length > 10 && !item.startsWith("[") && !item.startsWith("**")) {
+        const fullTitle = currentSection ? `${currentSection}: ${item}` : item
+        tickets.push({
+          title: fullTitle.length > 80 ? `${fullTitle.slice(0, 77)}...` : fullTitle,
+          description: item,
+        })
+      }
+      continue
+    }
+
+    // Detectar verbos de acción al inicio de oraciones
+    const actionVerbs = [
+      "implementar",
+      "crear",
+      "añadir",
+      "agregar",
+      "configurar",
+      "migrar",
+      "refactorizar",
+      "extraer",
+      "unificar",
+      "optimizar",
+      "documentar",
+    ]
+    const actionMatch = trimmed.match(new RegExp(`^(${actionVerbs.join("|")})\\s+`, "i"))
+    if (actionMatch && trimmed.length > 10 && trimmed.length < 120) {
+      tickets.push({
+        title: trimmed,
+        description: trimmed,
+      })
+    }
+  }
+
+  return tickets
+}
+
+// ─── API Pública ─────────────────────────────────────────────────────────────────
+
+/**
+ * Crea una nueva épica a partir de una descripción de feature o tarea grande.
+ * Opcionalmente genera tickets automáticamente analizando la descripción.
+ *
+ * @param {string} title - Título corto de la épica
+ * @param {string} description - Descripción detallada
+ * @param {object} [options]
+ * @param {boolean} [options.autoGenerateTickets=true] - Generar tickets automáticamente
+ * @param {string} [options.domain] - Dominio asociado
+ * @returns {Epic}
+ */
+export function createEpic(title, description, options = {}) {
+  const { autoGenerateTickets = true, domain } = options
+
+  if (!title || !title.trim()) {
+    throw new EpicManagerError("El título de la épica es requerido")
+  }
+
+  ensureDirs()
+  const existing = readAllEpics()
+  const epicId = generateId("EPIC", existing)
+
+  // Generar tickets si se solicita
+  const tickets = []
+  if (autoGenerateTickets) {
+    const extracted = extractTicketsFromDescription(description)
+    // Crear tickets reales en el sistema de bugs
+    for (const t of extracted) {
+      const ticketId = createBugTicket(t.title, t.description, domain || "shared")
+      if (ticketId) {
+        tickets.push({
+          id: ticketId,
+          title: t.title,
+          status: "open",
+        })
+      }
+    }
+  }
+
+  const epic = {
+    id: epicId,
+    title: title.trim(),
+    description: description.trim(),
+    status: "planning",
+    created: now(),
+    tickets,
+    sprints: [],
+    domain: domain || "shared",
+    metrics: {
+      totalTickets: tickets.length,
+      doneTickets: 0,
+      estimatedDays: estimateEpicDays(description, tickets.length),
+    },
+  }
+
+  writeEpic(epic)
+  return epic
+}
+
+/**
+ * Estima días de desarrollo para una épica.
+ * Heurística simple basada en número de tickets y complejidad textual.
+ *
+ * @param {string} description
+ * @param {number} ticketCount
+ * @returns {number}
+ */
+function estimateEpicDays(description, ticketCount) {
+  const complexityWords = [
+    "complej",
+    "difícil",
+    "ardu",
+    "grande",
+    "migración",
+    "rearquitectura",
+    "múltiple",
+    "varios",
+    "integracion",
+    "externa",
+  ]
+  const lower = description.toLowerCase()
+  const hasComplexity = complexityWords.some((w) => lower.includes(w))
+
+  const baseDays = Math.max(ticketCount * 1.5, 2)
+  return hasComplexity ? Math.ceil(baseDays * 1.5) : Math.ceil(baseDays)
+}
+
+/**
+ * Lista todas las épicas con sus métricas.
+ *
+ * @param {object} [options]
+ * @param {string} [options.status] - Filtrar por estado
+ * @param {string} [options.domain] - Filtrar por dominio
+ * @returns {Epic[]}
+ */
+export function listEpics(options = {}) {
+  let epics = readAllEpics()
+
+  if (options.status) {
+    epics = epics.filter((e) => e.status === options.status)
+  }
+
+  if (options.domain) {
+    epics = epics.filter((e) => e.domain === options.domain)
+  }
+
+  // Calcular métricas en vivo
+  for (const epic of epics) {
+    if (epic.metrics) {
+      const done = (epic.tickets || []).filter(
+        (t) => t.status === "done" || t.status === "fixed"
+      ).length
+      epic.metrics.doneTickets = done
+    }
+  }
+
+  // Ordenar por fecha de creación descendente
+  return epics.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime())
+}
+
+/**
+ * Actualiza el estado de una épica.
+ *
+ * @param {string} epicId
+ * @param {object} updates
+ * @param {string} [updates.status] - Nuevo estado
+ * @param {string} [updates.title] - Nuevo título
+ * @param {string} [updates.description] - Nueva descripción
+ * @returns {Epic}
+ */
+export function updateEpic(epicId, updates) {
+  const all = readAllEpics()
+  const epic = all.find((e) => e.id === epicId)
+  if (!epic) {
+    throw new EpicManagerError(`Épica no encontrada: ${epicId}`)
+  }
+
+  if (updates.status) {
+    epic.status = updates.status
+    if (updates.status === "active" && !epic.started) {
+      epic.started = now()
+    }
+    if (updates.status === "done" && !epic.completed) {
+      epic.completed = now()
+    }
+  }
+
+  if (updates.title) epic.title = updates.title
+  if (updates.description) epic.description = updates.description
+  if (updates.domain) epic.domain = updates.domain
+
+  writeEpic(epic)
+  return epic
+}
+
+/**
+ * Agrega tickets existentes a una épica.
+ *
+ * @param {string} epicId
+ * @param {string[]} ticketIds - IDs de tickets a agregar
+ * @returns {Epic}
+ */
+export function addTicketsToEpic(epicId, ticketIds) {
+  const epic = readEpic(epicId)
+  if (!epic) {
+    throw new EpicManagerError(`Épica no encontrada: ${epicId}`)
+  }
+
+  const existingIds = new Set((epic.tickets || []).map((t) => t.id))
+  for (const ticketId of ticketIds) {
+    if (!existingIds.has(ticketId)) {
+      epic.tickets.push({
+        id: ticketId,
+        title: ticketId,
+        status: "open",
+      })
+      existingIds.add(ticketId)
+    }
+  }
+
+  if (epic.metrics) {
+    epic.metrics.totalTickets = epic.tickets.length
+  }
+
+  writeEpic(epic)
+  return epic
+}
+
+// ─── Sprints ─────────────────────────────────────────────────────────────────────
+
+/**
+ * Crea un nuevo sprint.
+ *
+ * @param {string} name - Nombre del sprint (ej: "Sprint 1: Core")
+ * @param {string} goal - Objetivo del sprint
+ * @param {object} [options]
+ * @param {string} [options.startDate] - Fecha inicio (default: today)
+ * @param {number} [options.durationDays=14] - Duración en días
+ * @param {string[]} [options.ticketIds] - Tickets a incluir
+ * @param {string[]} [options.epicIds] - Épicas a cubrir
+ * @returns {Sprint}
+ */
+export function createSprint(name, goal, options = {}) {
+  const { ticketIds = [], epicIds = [], durationDays = 14 } = options
+
+  if (!name || !name.trim()) {
+    throw new EpicManagerError("El nombre del sprint es requerido")
+  }
+
+  ensureDirs()
+  const existing = readAllSprints()
+  const sprintId = generateId("SPRINT", existing)
+
+  const startDate = options.startDate || shortDate()
+  const endDate = new Date(Date.now() + durationDays * 86400000).toISOString().split("T")[0]
+
+  const sprint = {
+    id: sprintId,
+    name: name.trim(),
+    goal: goal.trim(),
+    status: "planning",
+    startDate,
+    endDate,
+    ticketIds,
+    epicIds,
+    metrics: {
+      totalTickets: ticketIds.length,
+      doneTickets: 0,
+      velocity: 0,
+    },
+  }
+
+  writeSprint(sprint)
+
+  // Vincular sprints a épicas
+  for (const epicId of epicIds) {
+    const epic = readEpic(epicId)
+    if (epic) {
+      if (!epic.sprints) epic.sprints = []
+      if (!epic.sprints.includes(sprintId)) {
+        epic.sprints.push(sprintId)
+        writeEpic(epic)
+      }
+    }
+  }
+
+  return sprint
+}
+
+/**
+ * Planifica un sprint automáticamente basado en capacidad y prioridades.
+ * Selecciona tickets de épicas activas que quepan en la capacidad estimada.
+ *
+ * @param {string} sprintId - ID del sprint a planificar
+ * @param {object} [options]
+ * @param {number} [options.capacity=10] - Capacidad estimada en tickets
+ * @param {string[]} [options.priorityEpics] - Épicas prioritarias
+ * @returns {Sprint}
+ */
+export function planSprint(sprintId, options = {}) {
+  const { capacity = 10, priorityEpics = [] } = options
+  const allSprints = readAllSprints()
+  const sprint = allSprints.find((s) => s.id === sprintId)
+
+  if (!sprint) {
+    throw new EpicManagerError(`Sprint no encontrado: ${sprintId}`)
+  }
+
+  // Obtener tickets de épicas activas
+  const allEpics = readAllEpics()
+  const activeEpics = allEpics.filter((e) => e.status === "active")
+
+  // Priorizar épicas
+  const sortedEpics = [...activeEpics].sort((a, b) => {
+    const aPriority = priorityEpics.includes(a.id) ? 0 : 1
+    const bPriority = priorityEpics.includes(b.id) ? 0 : 1
+    if (aPriority !== bPriority) return aPriority - bPriority
+    return (a.metrics?.estimatedDays || 5) - (b.metrics?.estimatedDays || 5)
+  })
+
+  // Seleccionar tickets hasta llenar capacidad
+  const selectedTickets = []
+  const selectedEpics = []
+  let count = 0
+
+  for (const epic of sortedEpics) {
+    if (count >= capacity) break
+    const openTickets = (epic.tickets || []).filter(
+      (t) => t.status === "open" || t.status === "backlog"
+    )
+    for (const ticket of openTickets) {
+      if (count >= capacity) break
+      selectedTickets.push(ticket.id)
+      count++
+    }
+    if (openTickets.length > 0) {
+      selectedEpics.push(epic.id)
+    }
+  }
+
+  // Actualizar sprint
+  sprint.ticketIds = selectedTickets
+  sprint.epicIds = [...new Set([...sprint.epicIds, ...selectedEpics])]
+  sprint.metrics.totalTickets = selectedTickets.length
+
+  writeSprint(sprint)
+  return sprint
+}
+
+/**
+ * Lista todos los sprints.
+ *
+ * @param {object} [options]
+ * @param {string} [options.status] - Filtrar por estado
+ * @returns {Sprint[]}
+ */
+export function listSprints(options = {}) {
+  let sprints = readAllSprints()
+
+  if (options.status) {
+    sprints = sprints.filter((s) => s.status === options.status)
+  }
+
+  // Calcular métricas en vivo
+  for (const sprint of sprints) {
+    if (sprint.metrics) {
+      const bugsDir = join(process.cwd(), ".opencode", "bugs")
+      if (existsSync(bugsDir)) {
+        let doneCount = 0
+        for (const ticketId of sprint.ticketIds || []) {
+          const files = readdirSync(bugsDir).filter((f) => f.startsWith(ticketId))
+          for (const f of files) {
+            try {
+              const content = readFileSync(join(bugsDir, f), "utf-8")
+              const statusMatch = content.match(/\*\*Estado\*\*\s+\|\s+(\w+)/)
+              if (statusMatch && ["done", "fixed"].includes(statusMatch[1])) {
+                doneCount++
+              }
+            } catch {
+              // Ignorar
+            }
+          }
+        }
+        sprint.metrics.doneTickets = doneCount
+      }
+    }
+  }
+
+  return sprints.sort((a, b) => new Date(b.startDate) - new Date(a.startDate))
+}
+
+/**
+ * Actualiza el estado de un sprint.
+ *
+ * @param {string} sprintId
+ * @param {object} updates
+ * @param {string} [updates.status]
+ * @param {string} [updates.goal]
+ * @param {string[]} [updates.ticketIds]
+ * @returns {Sprint}
+ */
+export function updateSprint(sprintId, updates) {
+  const all = readAllSprints()
+  const sprint = all.find((s) => s.id === sprintId)
+  if (!sprint) {
+    throw new EpicManagerError(`Sprint no encontrado: ${sprintId}`)
+  }
+
+  if (updates.status) sprint.status = updates.status
+  if (updates.goal) sprint.goal = updates.goal
+  if (updates.ticketIds) {
+    sprint.ticketIds = updates.ticketIds
+    if (sprint.metrics) sprint.metrics.totalTickets = updates.ticketIds.length
+  }
+
+  writeSprint(sprint)
+  return sprint
+}
+
+// ─── Plan Adjustment ─────────────────────────────────────────────────────────────
+
+/**
+ * Ajusta planes existentes cuando llega nuevo trabajo que se solapa.
+ * Detecta épicas activas con keywords similares y sugiere merge o priorización.
+ *
+ * @param {string} newTitle - Título de la nueva tarea/épica
+ * @param {string} newDescription - Descripción
+ * @returns {Array<{epicId:string, title:string, overlap:number, suggestion:string}>}
+ */
+export function detectPlanAdjustments(newTitle, newDescription) {
+  const epics = readAllEpics()
+  const activeEpics = epics.filter((e) => e.status !== "done" && e.status !== "cancelled")
+  const combinedText = `${newTitle} ${newDescription}`.toLowerCase()
+  const words = combinedText.split(/\s+/).filter((w) => w.length > 4)
+
+  if (words.length === 0) return []
+
+  const adjustments = []
+
+  for (const epic of activeEpics) {
+    const epicText = `${epic.title} ${epic.description}`.toLowerCase()
+    const overlapCount = words.filter((w) => epicText.includes(w)).length
+    const overlapRatio = overlapCount / words.length
+
+    if (overlapRatio > 0.3) {
+      let suggestion
+      if (overlapRatio > 0.6) {
+        suggestion =
+          "MERGE: La nueva tarea parece cubrir la misma épica existente. Considere fusionar."
+      } else if (overlapRatio > 0.4) {
+        suggestion =
+          "ALIGN: Superposición significativa. Revisar si la nueva tarea es un subconjunto o extensión."
+      } else {
+        suggestion = "NOTE: Superposición leve. Monitorear para evitar duplicación de esfuerzo."
+      }
+
+      adjustments.push({
+        epicId: epic.id,
+        title: epic.title,
+        overlapCount,
+        overlapRatio: Math.round(overlapRatio * 100),
+        suggestion,
+      })
+    }
+  }
+
+  return adjustments.sort((a, b) => b.overlapRatio - a.overlapRatio)
+}
+
+/**
+ * Genera un reporte de estado del proyecto basado en épicas y sprints.
+ *
+ * @returns {string} Reporte formateado
+ */
+export function generateStatusReport() {
+  const epics = readAllEpics()
+  const sprints = readAllSprints()
+
+  const activeEpics = epics.filter((e) => e.status === "active")
+  const doneEpics = epics.filter((e) => e.status === "done")
+  const totalTickets = epics.reduce((sum, e) => sum + (e.tickets?.length || 0), 0)
+  const doneTickets = epics.reduce(
+    (sum, e) =>
+      sum + (e.tickets?.filter((t) => t.status === "done" || t.status === "fixed").length || 0),
+    0
+  )
+  const plannedDays = epics.reduce((sum, e) => sum + (e.metrics?.estimatedDays || 0), 0)
+
+  const lines = []
+  lines.push("═══════════════════════════════════════")
+  lines.push("  REPORTE DE ESTADO DEL PROYECTO")
+  lines.push("═══════════════════════════════════════\n")
+
+  lines.push(
+    `  Épicas:        ${epics.length} totales (${activeEpics.length} activas, ${doneEpics.length} completadas)`
+  )
+  lines.push(
+    `  Tickets:       ${doneTickets}/${totalTickets} completados (${totalTickets > 0 ? Math.round((doneTickets / totalTickets) * 100) : 0}%)`
+  )
+  lines.push(`  Días estimados: ${plannedDays}`)
+  lines.push(`  Sprints:       ${sprints.length} totales`)
+  lines.push("")
+
+  if (activeEpics.length > 0) {
+    lines.push("  Épicas Activas:")
+    for (const epic of activeEpics) {
+      const donePct =
+        epic.metrics?.totalTickets > 0
+          ? Math.round(((epic.metrics.doneTickets || 0) / epic.metrics.totalTickets) * 100)
+          : 0
+      lines.push(`    ${epic.id}: ${epic.title} (${donePct}%)`)
+    }
+    lines.push("")
+  }
+
+  const activeSprints = sprints.filter((s) => s.status === "active")
+  if (activeSprints.length > 0) {
+    lines.push("  Sprints Activos:")
+    for (const sprint of activeSprints) {
+      const donePct =
+        sprint.metrics?.totalTickets > 0
+          ? Math.round(((sprint.metrics.doneTickets || 0) / sprint.metrics.totalTickets) * 100)
+          : 0
+      lines.push(`    ${sprint.id}: ${sprint.name} (${donePct}%)`)
+      lines.push(`      ${sprint.startDate} → ${sprint.endDate} | ${sprint.goal}`)
+    }
+    lines.push("")
+  }
+
+  lines.push("  Para crear una nueva épica:")
+  lines.push('    npx openPrompt-Lang epic create --title "..." --desc "..."')
+  lines.push("")
+
+  return lines.join("\n")
+}