openprompt-lang 0.7.0 → 0.9.0

package/src/cli/commands-misc.js

@@ -0,0 +1,248 @@
+// @use(commander, kind, contract, limit)
+// @kind(util)
+// @contract(in: program -> out: void, sideEffect: registra comandos misceláneos)
+// @limit(lines: 200)
+
+export function register(program) {
+  const component = program
+    .command('component')
+    .description('Gestionar biblioteca de componentes reutilizables')
+
+  component
+    .command('list')
+    .description('Listar componentes disponibles')
+    .option('--library <path>', 'Ruta a la biblioteca de componentes')
+    .option('--style <style>', 'Filtrar por estilo UI (shadcn, mantine, chakra, headless, mui)')
+    .option('--tech <tech>', 'Filtrar por tecnología (react, vue, angular)')
+    .option('--validated', 'Mostrar solo componentes validados/aprendidos')
+    .action(async (options) => {
+      const { componentList } = await import('../commands/component.js')
+      await componentList(options)
+    })
+
+  component
+    .command('add <name>')
+    .description('Agregar componente desde biblioteca o template del módulo de lenguaje')
+    .option('--library <path>', 'Ruta a la biblioteca de componentes')
+    .option('--template', 'Usar template del módulo de lenguaje (INDEX.json)')
+    .option('--lang <lang>', 'Lenguaje del template (default: de prompt-lang.json)')
+    .option('--variants <list>', 'Variantes a incluir (separadas por coma)')
+    .option('--output <name>', 'Nombre del archivo de salida (sin extensión)')
+    .option('--force', 'Sobrescribir archivo existente')
+    .option('--save', 'Marcar componente como validado/aprendido')
+    .action(async (name, options) => {
+      const { componentAdd } = await import('../commands/component.js')
+      await componentAdd(name, options)
+    })
+
+  component
+    .command('init')
+    .description('Inicializar una biblioteca de componentes')
+    .option('--library <path>', 'Ruta donde crear la biblioteca')
+    .option('--name <name>', 'Nombre de la biblioteca')
+    .action(async (options) => {
+      const { componentInit } = await import('../commands/component.js')
+      await componentInit(options)
+    })
+
+  component
+    .command('manifest')
+    .description('Mostrar el manifiesto de la biblioteca de componentes')
+    .option('--library <path>', 'Ruta a la biblioteca de componentes')
+    .action(async (options) => {
+      const { componentManifest } = await import('../commands/component.js')
+      await componentManifest(options)
+    })
+
+  const scaffold = program
+    .command('scaffold')
+    .description('Gestionar scafffolding de proyectos por framework')
+
+  scaffold
+    .command('folders <framework>')
+    .description('Crear estructura de carpetas según framework')
+    .option('--name <name>', 'Nombre del proyecto (directorio)')
+    .option('--force', 'Sobrescribir archivos existentes')
+    .action(async (framework, options) => {
+      const { scaffoldFolders } = await import('../commands/scaffold.js')
+      await scaffoldFolders(framework, options)
+    })
+
+  scaffold
+    .command('list')
+    .description('Listar frameworks disponibles en el catálogo')
+    .action(async () => {
+      const { scaffoldList } = await import('../commands/scaffold.js')
+      await scaffoldList()
+    })
+
+  program
+    .command('integrate')
+    .description('Configure Opencode, Cursor, and VS Code for the project')
+    .option('--all', 'Setup all integrations without prompting')
+    .option('--lang <lang>', 'Language (auto-detects from prompt-lang.json)')
+    .option('--no-ask', 'Skip interactive prompts')
+    .option('--from <dir>', 'Transferir contexto desde otro proyecto (memoria estructurada)')
+    .option('--to <dir>', 'Proyecto destino para la transferencia de contexto')
+    .option('--migrate', 'Modo migración: copiar contexto de negocio entre proyectos')
+    .action(async (options) => {
+      if (options.migrate || options.from) {
+        const { migrateContext } = await import('../commands/integrate.js')
+        await migrateContext(options)
+        return
+      }
+      const { integrate } = await import('../commands/integrate.js')
+      await integrate(options)
+    })
+
+  program
+    .command('local-setup')
+    .description('Configurar integración con IA local (Ollama + OpenCode)')
+    .option('--dry-run', 'Previsualizar sin crear archivos')
+    .action(async (options) => {
+      const { localSetup } = await import('../commands/local-setup.js')
+      await localSetup(options)
+    })
+
+  program
+    .command('db-rules')
+    .description('Consultar reglas de base de datos, anti-patrones y buenas prácticas')
+    .option('--list', 'Listar todas las reglas disponibles')
+    .option('--id <id>', 'Ver detalle de una regla específica (ej: db-001)')
+    .option('--tag <tag>', 'Filtrar por tag (ej: performance, security, supabase)')
+    .option('--category <cat>', 'Filtrar por categoría (ej: rendimiento, arquitectura)')
+    .action(async (options) => {
+      const { dbRules } = await import('../commands/db-rules.js')
+      await dbRules(options)
+    })
+
+  program
+    .command('qa-gen')
+    .description('Generate tests from learned errors (@learn-error)')
+    .option('--lang <lang>', 'Language module (default: from INDEX.json)')
+    .option('--source <dir>', 'Source directory to scan for @learn-error')
+    .option('--output <dir>', 'Output directory for generated tests (default: src/__tests__)')
+    .option('--template <id>', 'Generate tests only for a specific template')
+    .option('--dry-run', 'Preview without writing files')
+    .option('--no-scan', 'Skip scanning source for new @learn-error annotations')
+    .option('--from-tickets', 'Read tickets from .opencode/bugs/ and generate tests from them')
+    .action(async (options) => {
+      const { qaGen } = await import('../commands/qa-gen.js')
+      await qaGen(options)
+    })
+
+  program
+    .command('lint-file <file>')
+    .description('Lint a single file for OPL annotation errors')
+    .option('--strict', 'Enable strict mode (warnings become errors)')
+    .option('--lang <lang>', 'Language module for tag resolution (default: react)')
+    .action(async (file, options) => {
+      const { lintFileCli } = await import('../commands/qa-gen.js')
+      await lintFileCli(file, options)
+    })
+
+  program
+    .command('qa-learn')
+    .description('Parse @learn-error from a file and persist to language module')
+    .option('--file <path>', 'Source file to scan for @learn-error annotations')
+    .option('--lang <lang>', 'Language module (default: react)')
+    .action(async (options) => {
+      const { qaLearn } = await import('../commands/qa-gen.js')
+      await qaLearn(options)
+    })
+
+  program
+    .command('project-context')
+    .description('Gestionar PROJECT_CONTEXT.md — estado persistente del proyecto')
+    .option('--generate', 'Generar PROJECT_CONTEXT.md desde cero')
+    .option('--update', 'Actualizar estadísticas del contexto existente')
+    .option('--log-commit <msg>', 'Registrar un commit en PROJECT_CONTEXT.md')
+    .option('--log-error <error>', 'Registrar un error (uso: --log-error "msg" --fix "solucion" --lesson "leccion")')
+    .option('--fix <fix>', 'Solución del error (con --log-error)')
+    .option('--lesson <lesson>', 'Lección aprendida (con --log-error)')
+    .option('--log-activity <action>', 'Registrar actividad (uso: --log-activity "accion" --notes "notas")')
+    .option('--notes <notes>', 'Notas de la actividad (con --log-activity)')
+    .option('--dir <path>', 'Directorio base del proyecto (default: cwd)')
+    .action(async (options) => {
+      const { generateProjectContext, updateProjectContext, logCommit, logError, logActivity } = await import('../commands/project-context.js')
+      const baseDir = options.dir || process.cwd()
+      if (options.logCommit) {
+        await logCommit(baseDir, options.logCommit)
+      } else if (options.logError) {
+        await logError(baseDir, options.logError, options.fix || '-', options.lesson || '-')
+      } else if (options.logActivity) {
+        await logActivity(baseDir, options.logActivity, options.notes || '-')
+      } else if (options.update) {
+        await updateProjectContext(baseDir)
+      } else {
+        await generateProjectContext(baseDir)
+      }
+    })
+
+  program
+    .command('mcp')
+    .description('Start MCP server for opencode integration via stdio')
+    .action(async () => {
+      const { startServer } = await import('../mcp-server.js')
+      await startServer()
+    })
+
+  const ticket = program
+    .command('ticket')
+    .description('Gestión de tickets de bugs (proyecto y OPL)')
+
+  ticket
+    .command('create')
+    .description('Crear un nuevo ticket de bug')
+    .option('--title <title>', 'Título del ticket')
+    .option('--severity <severity>', 'Severidad: critical, high, medium, low')
+    .option('--project <name>', 'Nombre del proyecto')
+    .option('--file <path>', 'Archivo fuente del bug')
+    .option('--description <desc>', 'Descripción del bug')
+    .option('--learn-error <id>', 'ID de @learn-error relacionado')
+    .option('--type <type>', 'Tipo: OPL (framework) o project (default)')
+    .action(async (options) => {
+      const { ticketCreate } = await import('../commands/ticket.js')
+      await ticketCreate(options)
+    })
+
+  ticket
+    .command('list')
+    .description('Listar tickets del proyecto y OPL')
+    .option('--status <status>', 'Filtrar por estado: open, wip, fixed, wontfix')
+    .option('--severity <severity>', 'Filtrar por severidad')
+    .option('--project <name>', 'Filtrar por proyecto')
+    .action(async (options) => {
+      const { ticketList } = await import('../commands/ticket.js')
+      await ticketList(options)
+    })
+
+  ticket
+    .command('close <id>')
+    .description('Cerrar un ticket (marcar como fixed)')
+    .option('--fix <desc>', 'Descripción del fix aplicado')
+    .action(async (id, options) => {
+      const { ticketClose } = await import('../commands/ticket.js')
+      await ticketClose(id, options)
+    })
+
+  program
+    .command('doctor')
+    .description('Health-check: verificar que OPL y el proyecto están sanos')
+    .option('--dir <path>', 'Directorio del proyecto (default: cwd)')
+    .option('--verbose', 'Mostrar detalles adicionales')
+    .action(async (options) => {
+      const { doctor } = await import('../commands/doctor.js')
+      await doctor(options)
+    })
+
+  program
+    .command('recall <query>')
+    .description('Buscar en memoria del proyecto: aprendizajes, conceptos, errores, tickets')
+    .option('--lang <lang>', 'Módulo de lenguaje (default: react)')
+    .option('--dir <path>', 'Directorio del proyecto (default: cwd)')
+    .action(async (query, options) => {
+      const { recall } = await import('../commands/recall.js')
+      await recall(query, options)
+    })
+}

package/src/cli/commands-work.js

@@ -0,0 +1,94 @@
+// @use(commander, kind, contract, limit)
+// @kind(util)
+// @contract(in: program -> out: void, sideEffect: registra comandos work-context)
+// @limit(lines: 120)
+
+export function register(program) {
+  const workContext = program
+    .command('work-context')
+    .description('Gestionar contexto de trabajo, planes, logs y aprendizajes')
+
+  workContext
+    .command('init')
+    .description('Inicializar sistema work-context en proyecto existente')
+    .action(async () => {
+      const { init } = await import('../commands/work-context.js')
+      await init()
+    })
+
+  workContext
+    .command('status')
+    .description('Mostrar estado actual del contexto de trabajo')
+    .action(async () => {
+      const { status } = await import('../commands/work-context.js')
+      await status()
+    })
+
+  workContext
+    .command('start <description>')
+    .description('Iniciar una nueva sesión de trabajo')
+    .action(async (description) => {
+      const { start } = await import('../commands/work-context.js')
+      await start(description)
+    })
+
+  workContext
+    .command('log <message>')
+    .description('Añadir entrada a la bitácora')
+    .action(async (message) => {
+      const { log } = await import('../commands/work-context.js')
+      await log(message)
+    })
+
+  const planCmd = workContext.command('plan')
+    .description('Gestionar planes de trabajo')
+
+  planCmd
+    .command('new <name>')
+    .description('Crear un nuevo plan de trabajo')
+    .option('--task <description>', 'Descripción de la tarea para búsqueda de conocimiento')
+    .action(async (name, options) => {
+      const { plan } = await import('../commands/work-context.js')
+      await plan(name, options)
+    })
+
+  planCmd
+    .command('check [name]')
+    .description('Verificar un plan existente contra el conocimiento actual')
+    .action(async (name) => {
+      const { planCheck } = await import('../commands/work-context.js')
+      await planCheck(name)
+    })
+
+  workContext
+    .command('close')
+    .description('Cerrar la sesión activa y generar reporte')
+    .action(async () => {
+      const { close } = await import('../commands/work-context.js')
+      await close()
+    })
+
+  workContext
+    .command('learn')
+    .description('Extraer aprendizajes de la sesión a LEARNINGS.md')
+    .action(async () => {
+      const { learn } = await import('../commands/work-context.js')
+      await learn()
+    })
+
+  workContext
+    .command('report')
+    .description('Generar reporte completo del contexto de trabajo')
+    .action(async () => {
+      const { report } = await import('../commands/work-context.js')
+      await report()
+    })
+
+  workContext
+    .command('check')
+    .description('Verificar consistencia del work-context')
+    .action(async () => {
+      const { check } = await import('../commands/work-context.js')
+      await check()
+    })
+}

package/src/commands/ai-gen.js

@@ -1,3 +1,7 @@
+// @use(kind, contract, limit)
+// @kind(util)
+// @contract(in: prompt + options -> out: respuesta, sideEffect: stdout)
+// @limit(lines: 200)
 import { writeFileSync, existsSync, mkdirSync, readFileSync } from 'fs'
 import { join, relative } from 'path'
 import chalk from 'chalk'
@@ -46,7 +50,7 @@ export async function aiGen (options) {
 
   if (options.verbose) {
     console.log(chalk.gray('\n  Prompt preview:\n'))
-    console.log(chalk.gray(promptResult.prompt.slice(0, 600) + '...\n'))
+    console.log(chalk.gray(`${promptResult.prompt.slice(0, 600)  }...\n`))
   }
 
   // Generate

package/src/commands/component.js

@@ -1,3 +1,7 @@
+// @use(kind, contract, limit)
+// @kind(util)
+// @contract(in: args -> out: void, sideEffect: gestión de componentes)
+// @limit(lines: 200)
 import {
   readFileSync,
   writeFileSync,
@@ -394,7 +398,7 @@ function injectVariants (content, variants) {
   const inner = block.body.replace(/^variant:\s*\{/, '').replace(/\}\s*$/, '').trim()
   const lines = inner.split('\n').map((l) => l.trim())
   const kept = lines.filter((l) =>
-    variants.some((v) => l.startsWith(v + ':') || l.startsWith(`"${v}"`))
+    variants.some((v) => l.startsWith(`${v  }:`) || l.startsWith(`"${v}"`))
   )
   if (kept.length === 0) return content
 

package/src/commands/context.js

@@ -1,15 +1,21 @@
-// @use(kind, contract, limit)
-// @kind(service)
-// @contract(in: options -> out: void, sideEffect: contexto.md)
-// @limit(lines: 150)
+// @use(kind, contract, limit, learn-error)
+// @kind(feature)
+// @contract(in: options -> out: void, sideEffect: contexto.md + unified search)
+// @limit(lines: 600)
 
 import { readFileSync, writeFileSync, readdirSync, statSync, existsSync } from 'fs'
-import { join, relative, extname, basename } from 'path'
+import { join, relative, extname, basename, dirname } from 'path'
+import { fileURLToPath } from 'url'
 import { loadConfig } from '../utils/config.js'
 import { lintFile, parseAnnotations } from '../utils/annotations.js'
 import { searchConcepts } from '../utils/semantic-index.js'
+import { searchKnowledge } from '../utils/knowledge-search.js'
+import { searchTemplates as langSearchTemplates } from '../utils/language-loader.js'
+import { scanForLearnErrors } from '../utils/error-learner.js'
 import chalk from 'chalk'
 
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
 const IGNORED_DIRS = new Set([
   '.git', 'node_modules', 'dist', 'build', '.next', '.gemini',
   'coverage', '.nyc_output', '__pycache__', '.cache'
@@ -73,7 +79,7 @@ function shouldIgnore (name, isDir) {
 function matchesGlob (name, pattern) {
   if (pattern.includes('*')) {
     const regex = new RegExp(
-      '^' + pattern.split('*').map((s) => s.replace(/[.+^${}()|[\]\\]/g, '\\$&')).join('.*') + '$'
+      `^${  pattern.split('*').map((s) => s.replace(/[.+^${}()|[\]\\]/g, '\\$&')).join('.*')  }$`
     )
     return regex.test(name)
   }
@@ -309,12 +315,12 @@ export async function context (options) {
   const agentsPath = join(baseDir, 'AGENTS.md')
   if (existsSync(agentsPath)) {
     output += '## AGENTS.md\n\n'
-    output += readFileSync(agentsPath, 'utf-8') + '\n\n'
+    output += `${readFileSync(agentsPath, 'utf-8')  }\n\n`
   }
   const configPath = join(baseDir, 'prompt-lang.json')
   if (existsSync(configPath)) {
     output += '## prompt-lang.json\n\n```json\n'
-    output += readFileSync(configPath, 'utf-8') + '\n```\n\n'
+    output += `${readFileSync(configPath, 'utf-8')  }\n\`\`\`\n\n`
   }
 
   // Index mode: summary only
@@ -402,3 +408,169 @@ export async function context (options) {
   if (options.domain) console.log(chalk.green(`   Dominio: ${options.domain}`))
   console.log(chalk.green(`📄 Output: ${outputFile}`))
 }
+
+export async function contextUnified (options) {
+  const baseDir = options.dir || process.cwd()
+  const query = options.query || ''
+  const domain = options.domain
+  const langId = options.lang || 'react'
+
+  console.log(chalk.cyan(`\n🔍 Búsqueda unificada: "${query || domain || 'todo'}"\n`))
+
+  const results = {
+    knowledge: [],
+    learning: [],
+    semantic: [],
+    templates: [],
+    tickets: [],
+    errors: []
+  }
+
+  // 1. Knowledge search
+  if (query) {
+    console.log(chalk.blue('  📚 Buscando en knowledge...'))
+    try {
+      const kResults = searchKnowledge(query, { limit: 5 })
+      results.knowledge = (kResults || []).map(r => ({
+        title: r.title || r.bookTitle,
+        bookTitle: r.bookTitle || r.bookId,
+        snippet: r.snippet,
+        relevance: r.relevance || 1
+      }))
+    } catch { /* knowledge unavailable */ }
+  }
+
+  // 2. Semantic index
+  if (query) {
+    try {
+      const semantic = searchConcepts(query, langId)
+      if (Array.isArray(semantic)) results.semantic = semantic
+    } catch {}
+  }
+
+  // 3. Template search
+  if (query) {
+    try {
+      const langTemplates = langSearchTemplates(query, { lang: langId, limit: 5 })
+      results.templates = (langTemplates || []).map(t => ({
+        id: t.id,
+        name: t.name || t.id,
+        category: t.category || 'general',
+        description: t.description || ''
+      }))
+    } catch {}
+  }
+
+  // 4. Learning concepts
+  const learningDir = join(baseDir, '.opencode', 'learning', 'concepts')
+  if (existsSync(learningDir)) {
+    try {
+      for (const cat of readdirSync(learningDir)) {
+        if (cat === 'knowledge') continue // skip auto-extracted
+        const catDir = join(learningDir, cat)
+        for (const entry of readdirSync(catDir)) {
+          const conceptMd = join(catDir, entry, 'concept.md')
+          if (existsSync(conceptMd)) {
+            const c = readFileSync(conceptMd, 'utf-8')
+            if (!query || c.toLowerCase().includes(query.toLowerCase()) || entry.toLowerCase().includes(query.toLowerCase())) {
+              results.learning.push({ name: entry, category: cat, path: join(catDir, entry) })
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+
+  // 5. Tickets
+  const ticketDirs = [
+    join(baseDir, '.opencode', 'bugs'),
+    join(__dirname, '..', '..', 'BUGS-IDENTIFIED-IN-PROJECTS')
+  ]
+  for (const td of ticketDirs) {
+    if (!existsSync(td)) continue
+    try {
+      const idxPath = join(td, 'INDEX.md')
+      if (!existsSync(idxPath)) continue
+      const idx = readFileSync(idxPath, 'utf-8')
+      for (const line of idx.split('\n')) {
+        if (line.includes('| BUG-') && (!query || line.toLowerCase().includes(query.toLowerCase()))) {
+          const cols = line.split('|').map(c => c.trim()).filter(Boolean)
+          if (cols.length >= 4 && cols[3] !== 'fixed') {
+            results.tickets.push({ id: cols[0], title: cols[1], severity: cols[2], status: cols[3] })
+          }
+        }
+      }
+    } catch {}
+  }
+
+  // 6. Learn-errors from source
+  if (query) {
+    try {
+      const foundErrors = scanForLearnErrors(baseDir, langId)
+      results.errors = foundErrors.filter(e =>
+        e.id.toLowerCase().includes(query.toLowerCase()) ||
+        (e.problem && e.problem.toLowerCase().includes(query.toLowerCase())) ||
+        (e.category && e.category.toLowerCase().includes(query.toLowerCase()))
+      ).slice(0, 10)
+    } catch {}
+  }
+
+  // Output
+  let totalResults = results.knowledge.length + results.learning.length + results.semantic.length +
+    results.templates.length + results.tickets.length + results.errors.length
+
+  if (totalResults === 0) {
+    console.log(chalk.yellow('  📭 Sin resultados para esta búsqueda.\n'))
+    return
+  }
+
+  if (results.knowledge.length > 0) {
+    console.log(chalk.cyan(`\n📚 Knowledge (${results.knowledge.length}):\n`))
+    for (const r of results.knowledge.slice(0, 5)) {
+      console.log(`  ${chalk.bold(r.title)} (relevance: ${r.relevance})`)
+      if (r.snippet) console.log(chalk.gray(`     ${r.snippet.slice(0, 100)}...`))
+      if (r.bookTitle) console.log(chalk.gray(`     Fuente: ${r.bookTitle}`))
+    }
+  }
+
+  if (results.semantic.length > 0) {
+    console.log(chalk.cyan(`\n🧩 Semántico (${results.semantic.length}):\n`))
+    for (const r of results.semantic.slice(0, 5)) {
+      console.log(`  ${chalk.bold(r.concept)} → ${(r.components || []).join(', ')}`)
+      if (r.patterns?.length) console.log(chalk.gray(`     Patrones: ${r.patterns.join(', ')}`))
+    }
+  }
+
+  if (results.templates.length > 0) {
+    console.log(chalk.cyan(`\n📄 Templates (${results.templates.length}):\n`))
+    for (const t of results.templates.slice(0, 5)) {
+      console.log(`  ${chalk.bold(t.id)} [${t.category}] — ${t.description || t.name}`)
+    }
+  }
+
+  if (results.learning.length > 0) {
+    console.log(chalk.cyan(`\n🧠 Learning (${results.learning.length}):\n`))
+    for (const l of results.learning.slice(0, 5)) {
+      console.log(`  ${chalk.bold(l.name)} (${l.category})`)
+    }
+  }
+
+  if (results.tickets.length > 0) {
+    console.log(chalk.cyan(`\n📋 Tickets (${results.tickets.length}):\n`))
+    for (const t of results.tickets.slice(0, 5)) {
+      const sevColor = { critical: chalk.red, high: chalk.yellow, medium: chalk.cyan, low: chalk.gray }[t.severity] || chalk.white
+      console.log(`  ${t.id} ${sevColor(`[${t.severity}]`)} — ${t.title}`)
+    }
+  }
+
+  if (results.errors.length > 0) {
+    console.log(chalk.cyan(`\n🐛 Errores aprendidos (${results.errors.length}):\n`))
+    for (const e of results.errors.slice(0, 5)) {
+      console.log(`  ${chalk.bold(e.id)}: ${e.problem}`)
+      if (e.solution) console.log(chalk.gray(`     Fix: ${e.solution}`))
+    }
+  }
+
+  console.log(chalk.green(`\n  ✅ ${totalResults} resultados en 6 fuentes\n`))
+  return results
+}

package/src/commands/db-rules.js

@@ -1,3 +1,7 @@
+// @use(kind, contract, limit)
+// @kind(util)
+// @contract(in: args -> out: void, sideEffect: muestra reglas de DB)
+// @limit(lines: 100)
 import { readFileSync, existsSync } from 'fs'
 import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
@@ -113,5 +117,5 @@ function printRuleBrief (r) {
 
 function printAntiPatternBrief (ap) {
   console.log(`   ${chalk.red(ap.id)} ${ap.title}`)
-  console.log(`     ${chalk.yellow('⚠️  ' + ap.problem)}`)
+  console.log(`     ${chalk.yellow(`⚠️  ${  ap.problem}`)}`)
 }