openprompt-lang 0.8.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openprompt-lang",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "PromptLang CLI — Context Engine de anotaciones para desarrollo asistido por IA",
   "type": "module",
   "main": "./bin/cli.js",

package/src/ai/prompt-builder.js

@@ -1,11 +1,13 @@
-import { readFileSync } from 'fs'
+import { readFileSync, existsSync, readdirSync } from 'fs'
 import { join } from 'path'
 import { getLanguageIndex, getLanguagePath } from '../utils/language-loader.js'
+import { searchKnowledge } from '../utils/knowledge-search.js'
 
 export function buildPrompt (description, options = {}) {
   const langId = options.lang || 'react'
   const index = getLanguageIndex(langId)
   const profile = options.profile || 'mid'
+  const baseDir = options.dir || process.cwd()
 
   const relevantTemplates = findRelevantTemplates(description, index)
 
@@ -20,6 +22,10 @@ export function buildPrompt (description, options = {}) {
     }
   }
 
+  // Inject project context: session, learning, learn-errors, config
+  const projectContext = buildProjectContext(baseDir, langId, description)
+  const knowledgeContext = buildKnowledgeContext(description)
+
   const kind = detectKind(description)
   const componentName = options.name || suggestName(description, kind)
 
@@ -37,12 +43,14 @@ export function buildPrompt (description, options = {}) {
     '- Include @use() annotation at the top with the tags you use',
     '- Include @kind, @props (if component), @contract (if hook/service), @limit, @test annotations',
     templateExamples,
+    projectContext,
+    knowledgeContext,
     `## Language: ${langId}`,
     '## Profile rules:',
     ...getProfileRules(profile),
     '',
     'Return ONLY the code, no markdown wrapping or explanation.'
-  ].join('\n')
+  ].filter(Boolean).join('\n')
 
   return { componentName, kind, systemPrompt, userPrompt, prompt: userPrompt }
 }
@@ -180,3 +188,69 @@ function getProfileRules (profile) {
 
   return rules[profile] || rules.mid
 }
+
+function buildProjectContext (baseDir, langId, description) {
+  const parts = []
+
+  // Session
+  const sessionPath = join(baseDir, '.opencode', 'work-context', 'SESSION.json')
+  if (existsSync(sessionPath)) {
+    try {
+      const session = JSON.parse(readFileSync(sessionPath, 'utf-8'))
+      if (session?.session?.task?.description) {
+        parts.push(`- Current session task: ${session.session.task.description}`)
+      }
+    } catch {}
+  }
+
+  // Project config
+  const configPath = join(baseDir, 'prompt-lang.json')
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'))
+      parts.push(`- Project: ${config.name || 'unnamed'} (${config.lenguaje || langId})`)
+      if (config.stack?.base) parts.push(`- Stack: ${config.stack.base.join(', ')}`)
+      if (config.stack?.extensions?.length) parts.push(`- Extensions: ${config.stack.extensions.join(', ')}`)
+    } catch {}
+  }
+
+  // Learning concepts relevant to description
+  const learningDir = join(baseDir, '.opencode', 'learning', 'concepts')
+  if (existsSync(learningDir)) {
+    try {
+      const desc = description.toLowerCase()
+      const found = []
+      for (const cat of readdirSync(learningDir)) {
+        const catDir = join(learningDir, cat)
+        for (const entry of readdirSync(catDir)) {
+          const conceptMd = join(catDir, entry, 'concept.md')
+          if (existsSync(conceptMd)) {
+            const content = readFileSync(conceptMd, 'utf-8').toLowerCase()
+            if (content.includes(desc) || entry.includes(desc)) {
+              found.push(`${entry} (${cat})`)
+            }
+          }
+        }
+      }
+      if (found.length > 0) parts.push(`- Relevant learning concepts: ${found.slice(0, 3).join(', ')}`)
+    } catch {}
+  }
+
+  if (parts.length === 0) return ''
+  return '\n## Project context:\n' + parts.map(p => `${p}`).join('\n') + '\n'
+}
+
+function buildKnowledgeContext (description) {
+  try {
+    const kResults = searchKnowledge(description, { limit: 3 })
+    if (!kResults || kResults.length === 0) return ''
+
+    const parts = ['\n## Relevant knowledge:\n']
+    for (const r of kResults) {
+      parts.push(`- ${r.title || r.bookTitle}: ${(r.snippet || '').slice(0, 150)}`)
+    }
+    return parts.join('\n') + '\n'
+  } catch {
+    return ''
+  }
+}

package/src/cli/commands-context.js

@@ -15,11 +15,39 @@ export function register(program) {
     .option('--domain <domain>', 'Filtrar por dominio de negocio (ecommerce, saas, mobile, api, admin, blog)')
     .option('--projects <list>', 'Proyectos vecinos a referenciar (separados por coma)')
     .option('--dir <path>', 'Directorio base del proyecto (default: cwd)')
+    .option('--unified', 'Búsqueda unificada: knowledge + learning + templates + tickets + semántico')
     .action(async (options) => {
-      const { context } = await import('../commands/context.js')
+      const { context, contextUnified } = await import('../commands/context.js')
+      if (options.unified) {
+        await contextUnified(options)
+        return
+      }
       await context(options)
     })
 
+  program
+    .command('docs')
+    .description('Generar FRAMEWORK.md desde el estado actual del proyecto')
+    .option('--output <file>', 'Archivo de salida', '.openprompt/FRAMEWORK.md')
+    .option('--dir <path>', 'Directorio del proyecto (default: cwd)')
+    .option('--dry-run', 'Mostrar sin escribir archivo')
+    .action(async (options) => {
+      const { generateFrameworkMd } = await import('../utils/generate-framework-md.js')
+      const output = generateFrameworkMd({ dir: options.dir || process.cwd() })
+      if (options.dryRun) {
+        console.log(output.slice(0, 2000))
+        console.log('\n... (truncado en dry-run)')
+        return
+      }
+      const { writeFileSync, existsSync, mkdirSync } = await import('fs')
+      const { join, dirname } = await import('path')
+      const outputPath = join(options.dir || process.cwd(), options.output)
+      const outDir = dirname(outputPath)
+      if (!existsSync(outDir)) mkdirSync(outDir, { recursive: true })
+      writeFileSync(outputPath, output, 'utf-8')
+      console.log(`✅ FRAMEWORK.md generado: ${outputPath}`)
+    })
+
   program
     .command('validate')
     .description('Ejecutar pipeline de validación y verificar anotaciones')

package/src/cli/commands-knowledge.js

@@ -47,6 +47,7 @@ export function register(program) {
   knowledge
     .command('to-learning')
     .description('Integrar PDFs procesados a la memoria semántica (learning)')
+    .option('--all', 'Procesar todos los PDFs disponibles')
     .option('--pdf <id>', 'Integrar solo un PDF específico por ID')
     .option('--force', 'Re-integran aunque ya estén integrados')
     .action(async (options) => {

package/src/cli/commands-learning.js

@@ -29,6 +29,7 @@ export function register(program) {
     .command('add <name>')
     .description('Crear un nuevo concepto con template')
     .option('--category <cat>', 'Categoría del concepto (default: visual)')
+    .option('--tags <tags>', 'Tags separados por coma (ej: modal,accesibilidad)')
     .action(async (name, options) => {
       const { add } = await import('../commands/learning.js')
       await add(name, options)

package/src/cli/commands-misc.js

@@ -125,11 +125,22 @@ export function register(program) {
     .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')
@@ -175,4 +186,63 @@ export function register(program) {
       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/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'
@@ -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
+}