openprompt-lang 1.2.7 → 1.4.0

package/docs/OPL_ACADEMIC_ISSUES.md

@@ -0,0 +1,158 @@
+# 🎓 OPL Academic — Bitácora de Problemas
+
+> Documento para registrar problemas, fricciones y errores detectados en el sistema de enseñanza (Teaching System) de openPrompt-Lang.
+> Cada entrada documenta: síntoma, causa raíz, impacto, solución propuesta y estado.
+
+---
+
+## 📋 Índice de Problemas
+
+| # | Fecha | Título | Severidad | Estado |
+|---|-------|--------|-----------|--------|
+| 1 | 2026-05-24 | Onboarding IA en proyecto existente | 🔴 Alta | Abierto |
+| 2 | 2026-05-24 | `opl rebuild` no detecta OPL automáticamente | 🟡 Media | Abierto |
+| 3 | 2026-05-24 | Falta documento post-init para IA | 🔴 Alta | Abierto |
+
+---
+
+## 🐛 Problemas Reportados
+
+### P-001: Onboarding IA en proyecto existente
+
+| Campo | Valor |
+|-------|-------|
+| **Fecha** | 2026-05-24 |
+| **Reportado por** | usuario |
+| **Severidad** | 🔴 Alta |
+| **Módulo** | Academic — Init / Onboarding |
+| **Estado** | 🔴 Abierto |
+
+**Síntoma:**
+Al iniciar una sesión con IA en un proyecto existente que ya tiene elementos de OPL, la IA no sabe qué hacer. No hay un punto de entrada claro que le diga "esto ya tiene OPL, aquí está el estado actual, continúa desde aquí".
+
+**Causa raíz:**
+No existe un documento de onboarding generado automáticamente que la IA pueda leer al inicio de cada sesión para restaurar contexto.
+
+**Impacto:**
+- La IA pierde ~15 minutos regenerando contexto cada sesión
+- Toma decisiones inconsistentes porque no conoce el estado real del proyecto
+- El usuario tiene que re-explicar manualmente lo que ya se hizo
+
+**Solución propuesta:**
+- Crear `docs/ONBOARDING_WORKFLOW.md` — documento canónico que la IA lee al iniciar
+- Integrar `opl init` para que genere este documento automáticamente
+- Dos versiones: `INICIAR_NUEVO.md` (proyecto nuevo) e `INICIAR_EXISTENTE.md` (proyecto en curso)
+
+**Referencias:**
+- `erroresDeFlujo.md` (línea 2)
+- Sprint embeddings → TICKET-011 (propuesto)
+
+---
+
+### P-002: `opl rebuild` no detecta OPL automáticamente
+
+| Campo | Valor |
+|-------|-------|
+| **Fecha** | 2026-05-24 |
+| **Reportado por** | usuario |
+| **Severidad** | 🟡 Media |
+| **Módulo** | CLI — rebuild |
+| **Estado** | 🟡 Abierto |
+
+**Síntoma:**
+`opl rebuild` falla o funciona incorrectamente cuando los elementos de OPL no están presentes o no son detectables automáticamente.
+
+**Causa raíz:**
+El comando `rebuild` asume cierta estructura pre-existente en lugar de ser autosuficiente.
+
+**Solución propuesta:**
+Hacer que `rebuild` funciones en dos modos:
+1. **Con detección**: Si encuentra elementos OPL, los respeta y reconstruye
+2. **Sin detección**: Si no encuentra nada, crea la estructura desde cero con defaults inteligentes
+
+**Referencias:**
+- `erroresDeFlujo.md` (línea 4)
+
+---
+
+### P-003: Falta documento post-init para IA
+
+| Campo | Valor |
+|-------|-------|
+| **Fecha** | 2026-05-24 |
+| **Reportado por** | usuario |
+| **Severidad** | 🔴 Alta |
+| **Módulo** | CLI — init |
+| **Estado** | 🔴 Abierto |
+
+**Síntoma:**
+Después de ejecutar `opl init`, no se genera ningún documento que la IA pueda usar para entender el contexto del proyecto. La IA llega "en frío" a cada sesión.
+
+**Causa raíz:**
+`opl init` configura el proyecto (crea prompt-lang.json, AGENTS.md, etc.) pero no genera un punto de entrada específico para la IA que le diga "esto es lo que hay, esto es lo que falta, continúa".
+
+**Solución propuesta:**
+Que `opl init` genere automáticamente:
+- `INICIAR_NUEVO.md` si es proyecto nuevo
+- `INICIAR_EXISTENTE.md` si es proyecto existente con OPL
+
+Estos documentos deben incluir:
+- Stack detectado
+- Estado de la configuración OPL
+- Próximos pasos recomendados
+- Enlace a `AGENTS.md` y `docs/AI_CONTEXT.md`
+
+**Referencias:**
+- `erroresDeFlujo.md` (línea 6)
+- `docs/ONBOARDING_WORKFLOW.md`
+
+---
+
+## 📊 Estadísticas
+
+| Métrica | Valor |
+|---------|-------|
+| Total problemas | 3 |
+| Severidad Alta | 2 |
+| Severidad Media | 1 |
+| Severidad Baja | 0 |
+| Abiertos | 3 |
+| En Progreso | 0 |
+| Resueltos | 0 |
+
+---
+
+## 📝 Cómo Reportar un Problema Nuevo
+
+Usa esta plantilla al añadir una nueva entrada:
+
+```markdown
+### P-XXX: Título descriptivo
+
+| Campo | Valor |
+|-------|-------|
+| **Fecha** | YYYY-MM-DD |
+| **Reportado por** | — |
+| **Severidad** | 🔴 Alta / 🟡 Media / 🟢 Baja |
+| **Módulo** | — |
+| **Estado** | 🔴 Abierto |
+
+**Síntoma:**
+_¿Qué ocurre exactamente?_
+
+**Causa raíz:**
+_¿Por qué ocurre?_
+
+**Impacto:**
+_¿A quién afecta y cómo?_
+
+**Solución propuesta:**
+_¿Cómo se arreglaría?_
+
+**Referencias:**
+- _enlaces a código, docs, commits_
+```
+
+---
+
+*Última actualización: 2026-05-24*

package/docs/WEB_SCRAPER_PLAN.md

@@ -0,0 +1,454 @@
+# Web Scraper Evolution — Plan Ollama-Driven
+
+> **Versión:** 2.0 (revisado)
+> **Objetivo:** Reemplazar `opl webscrape` (Readability.js + Turndown) por un extractor
+> **inteligente asistido por Ollama** que analiza la estructura de cada página y genera
+> un plan de extracción personalizado.
+>
+> **Stack:** 100% Node.js + Ollama (local) → Sin dependencia de Python.
+> **Principio:** Cada página es única → cada página merece un plan de extracción único.
+
+---
+
+## 1. Filosofía: Por qué IA en vez de Reglas Fijas
+
+### Enfoque tradicional (hardcoded)
+```python
+# Reglas fijas que fallan en el 50% de las páginas
+extract_og_tags(html)
+extract_metadata(html)
+extract_articles(html)
+extract_tables(html)
+```
+❌ Cada sitio tiene markup distinto → reglas imposibles de mantener
+❌ No entiende el **significado** de las secciones
+❌ No distingue contenido principal de navegación/publicidad
+❌ Cada nuevo tipo de página requiere más reglas
+
+### Enfoque Ollama-driven
+```
+fetch(url) → HTML + layout estructurado
+                    ↓
+          🧠 Ollama analiza: "¿qué hay aquí?"
+                    ↓
+          ← plan de extracción JSON ←
+                    ↓
+          Ejecuta el plan (selectores dinámicos)
+                    ↓
+          knowledge/<domain>/<slug>/
+```
+✅ Se adapta a cualquier página
+✅ Entiende semántica del contenido
+✅ Decide QUÉ extraer según el tipo de página
+✅ Sin reglas hardcodeadas — el LLM decide
+
+---
+
+## 2. Arquitectura General
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│  Input                                                           │
+│  url → fetchPage(url)                                           │
+│         ├── simple: node-fetch (rápido, HTML estático)           │
+│         └── headless: @playwright (SPA, JS-heavy, lazy-load)    │
+│                                                                  │
+│  Resultado: PageSnapshot { html, text, links, meta, ...}         │
+└──────────────────┬───────────────────────────────────────────────┘
+                   ↓
+┌──────────────────┴───────────────────────────────────────────────┐
+│  PASO 1: 🧠 Escaneo con Ollama (analyzePage)                    │
+│                                                                  │
+│  Envía a Ollama:                                                 │
+│  - Título de la página                                           │
+│  - Meta tags básicos                                             │
+│  - HTML estructural resumido (árbol de secciones, no el HTML     │
+│    completo — eso sería demasiado tokens)                         │
+│  - Texto visible (primeros ~2000 chars)                          │
+│  - Cantidad y tipos de elementos (cuántos <article>, <section>,  │
+│    <table>, <img>, <form>, cards, listas, etc.)                  │
+│                                                                  │
+│  Ollama responde:                                                │
+│  {                                                               │
+│    pageType: "article" | "product" | "docs" | "blog" |           │
+│               "catalog" | "landing" | "profile" | "generic",     │
+│    title: "Título detectado",                                    │
+│    description: "Descripción detectada",                          │
+│    contentBlocks: [                                              │
+│      {                                                           │
+│        type: "main-content" | "sidebar" | "nav" | "footer" |     │
+│              "cards" | "table" | "form" | "gallery",             │
+│        selector: "main article",      ← selector CSS sugerido   │
+│        importance: 1-10,               ← qué tan importante     │
+│        extractMode: "markdown" | "json" | "table" | "cards",    │
+│        description: "El artículo principal con su contenido"     │
+│      }                                                           │
+│    ],                                                            │
+│    metadata: {                                                   │
+│      og: true, twitter: true, jsonld: true, microdata: false     │
+│    },                                                            │
+│    specialFeatures: ["scroll-infinity", "load-more",             │
+│                      "pagination", "tabs", "accordion"],         │
+│    extractionPlan: {                                             │
+│      steps: ["extract-main-content", "extract-og",               │
+│              "extract-images", "extract-tables"],                │
+│      outputFormat: "markdown+json"                              │
+│    }                                                             │
+│  }                                                               │
+└──────────────────┬───────────────────────────────────────────────┘
+                   ↓
+┌──────────────────┴───────────────────────────────────────────────┐
+│  PASO 2: Ejecutar el plan (executePlan)                          │
+│                                                                  │
+│  Según el plan de Ollama, ejecuta SOLO los extractores           │
+│  necesarios para esta página:                                    │
+│                                                                  │
+│  ├── main-content: Readability.js + limpieza                     │
+│  ├── og/twitter/jsonld: extractores específicos (jsdom)          │
+│  ├── images: src, alt, caption, dimensiones                      │
+│  ├── tables: caption + headers + rows (markdown/JSON)            │
+│  ├── cards: tarjetas de producto/artículo/post                   │
+│  ├── forms: action, method, inputs                               │
+│  └── special: auto-scroll, load-more, pagination                 │
+│                                                                  │
+│  Resultado: ExtractedPage { ... }                                │
+└──────────────────┬───────────────────────────────────────────────┘
+                   ↓
+┌──────────────────┴───────────────────────────────────────────────┐
+│  PASO 3: Post-procesamiento (postProcess)                        │
+│                                                                  │
+│  ├── Convertir a markdown estructurado                           │
+│  ├── Clasificar contenido (dominio OPL)                          │
+│  ├── Generar resumen con Ollama (opcional)                       │
+│  ├── Generar embeddings vía pipeline existente                   │
+│  └── Guardar en knowledge/<domain>/<slug>/                       │
+│       ├── page.md         ← markdown completo                    │
+│       ├── metadata.json   ← datos estructurados                  │
+│       ├── plan.json       ← el plan que usó Ollama               │
+│       └── embeddings.json ← vectores                             │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 3. Componentes a Implementar
+
+### 3.1 Core (`src/core/webscrape/`)
+
+| Archivo | Descripción | Deps |
+|---------|-------------|------|
+| `analyzer.js` | Envía estructura de página a Ollama, recibe plan JSON | `@xenova/transformers`? No, es puro Ollama API |
+| `executor.js` | Ejecuta el plan de extracción paso a paso | `jsdom` |
+| `fetcher.js` | Fetch de página (simple + headless) | `node-fetch`, `playwright` (opt) |
+| `models.js` | PageSnapshot, ExtractPlan, ExtractedPage, PageType | — |
+| `postprocessor.js` | Markdown, metadata, embeddings, guardado | — |
+| `config.js` | URL de Ollama, timeouts, modelos, cache | — |
+
+### 3.2 Extractores (`src/core/webscrape/extractors/`)
+
+| Archivo | Descripción |
+|---------|-------------|
+| `extract-content.js` | Extrae contenido principal (Readability.js mejorado) |
+| `extract-og.js` | Open Graph + Twitter Cards |
+| `extract-jsonld.js` | JSON-LD structured data |
+| `extract-microdata.js` | Microdata / schema.org |
+| `extract-images.js` | Imágenes con alt, caption, dimensiones |
+| `extract-tables.js` | Tablas con caption, headers, rows |
+| `extract-cards.js` | Tarjetas de producto/artículo/post |
+| `extract-forms.js` | Formularios con campos |
+| `extract-special.js` | Load-more, paginación, scroll infinito |
+
+### 3.3 CLI (`src/commands/opl-webscrape.js`)
+
+```bash
+opl webscrape <url>                          # Modo normal (Ollama analyze + execute)
+opl webscrape <url> --plan-only              # Solo mostrar el plan de Ollama, no ejecutar
+opl webscrape <url> --plan <plan.json>        # Usar un plan guardado (re-ejecutar)
+opl webscrape <url> --simple                  # Forzar Readability.js (sin Ollama)
+opl webscrape <url> --headless                # Forzar Playwright (para SPAs)
+opl webscrape <url> --output json             # Salida JSON estructurada
+opl webscrape <url> --no-embeddings           # No generar embeddings
+opl webscrape <url> --dry-run                 # Mostrar plan sin guardar
+opl webscrape plan <url>                      # Shorthand para --plan-only
+```
+
+---
+
+## 4. Prompt de Análisis (Ollama)
+
+El prompt que se envía a Ollama es **la pieza clave**. Debe ser:
+
+- Compacto (no enviar HTML completo — solo resumen estructural)
+- Rico en señales semánticas (tipo de elementos, no su contenido)
+- Determinista en la respuesta (JSON estructurado)
+
+### Formato del prompt
+
+```
+Eres un analista de páginas web. Tu trabajo es examinar la estructura
+de una página web y generar un plan de extracción.
+
+## Información de la página
+URL: {url}
+Título: {title}
+Meta description: {description}
+Tamaño HTML: {htmlSize} chars
+
+## Resumen estructural
+- Tipo de elementos en la página:
+  {summary: article: 3, section: 5, nav: 1, main: 1, aside: 2,
+   footer: 1, table: 1, form: 0, img: 12, video: 0, article_card: 6,
+   list: 4, breadcrumb: 0}
+- Primeros 2000 caracteres del texto visible:
+  "{truncatedText}"
+
+## Enlaces principales (primeros 10)
+{links: [
+  {href: "/articulo-1", text: "Cómo hacer X", type: "internal"},
+  {href: "/categoria/y", text: "Categoría Y", type: "internal"},
+  ...
+]}
+
+## Meta tags encontrados
+{meta: {
+  og: ["og:title", "og:description", "og:image"],
+  twitter: ["twitter:card", "twitter:site"],
+  jsonld: true,
+  microdata: false
+}}
+
+## Instrucciones
+Analiza esta página y devuelve un JSON con:
+1. pageType: qué tipo de página es
+2. contentBlocks: qué bloques de contenido identificas y cómo extraerlos
+3. extractionPlan: pasos concretos a seguir
+4. metadata: qué meta tags extraer
+5. specialFeatures: si hay scroll infinito, load-more, paginación, etc.
+
+Responde ÚNICAMENTE con el JSON. No incluyas explicaciones.
+```
+
+### Respuesta esperada
+
+```json
+{
+  "pageType": "article",
+  "confidence": 0.92,
+  "title": "Cómo implementar un scraper con IA",
+  "description": "Guía paso a paso para construir un extractor web inteligente",
+  "contentBlocks": [
+    {
+      "type": "main-content",
+      "selector": "main article",
+      "importance": 10,
+      "extractMode": "markdown",
+      "description": "Artículo principal con contenido completo"
+    },
+    {
+      "type": "sidebar",
+      "selector": "aside.related-posts",
+      "importance": 3,
+      "extractMode": "links",
+      "description": "Artículos relacionados en la barra lateral"
+    }
+  ],
+  "metadata": {
+    "og": true,
+    "twitter": true,
+    "jsonld": true,
+    "microdata": false,
+    "priority": ["og:title", "og:description", "og:image"]
+  },
+  "specialFeatures": [],
+  "extractionPlan": {
+    "steps": [
+      "extract-main-content",
+      "extract-og",
+      "extract-jsonld",
+      "extract-images"
+    ],
+    "outputFormat": "markdown+json",
+    "notes": "Página de blog estándar con contenido principal rico en imágenes"
+  }
+}
+```
+
+---
+
+## 5. Integración con el Sistema OPL Existente
+
+### Pipeline completo con embeddings
+
+```
+cli: opl webscrape https://ejemplo.com/articulo
+  ↓
+fetcher.fetch(url) → PageSnapshot { html, text, links, meta, elementCounts }
+  ↓
+analyzer.analyze(snapshot, ollama) → ExtractPlan { pageType, blocks, steps }
+  ↓
+executor.execute(html, plan) → ExtractedPage { content, metadata, media, ... }
+  ↓
+postprocessor.process(extracted) → { markdown, metadata, cards }
+  ↓
+  → knowledge/<domain>/<slug>/page.md
+  → knowledge/<domain>/<slug>/metadata.json
+  → knowledge/<domain>/<slug>/plan.json
+  → knowledge/<domain>/<slug>/cards.json  (si aplica)
+  ↓
+embedder.indexDocument(slug)  ← pipeline de embeddings existente
+```
+
+### Reutilización de infraestructura existente
+
+| Componente OPL existente | Se reutiliza |
+|--------------------------|:------------:|
+| `src/embeddings/pipeline.js` | ✅ Indexación automática |
+| `src/embeddings/sqlite-store.js` | ✅ Cache + almacenamiento |
+| `src/commands/opl-webscrape.js` | ✅ Refactorizado como entry point |
+| `src/cli/commands-opl.js` | ✅ Flags nuevos (`--plan-only`, `--headless`) |
+| Readability.js + Turndown | ✅ Como extractores de contenido (PASO 2) |
+| `opl knowledge` | ✅ Integración con knowledge base |
+
+---
+
+## 6. Estrategia de Implementación por Fases
+
+| Fase | Qué se hace | Archivos | Esfuerzo |
+|------|-------------|----------|:--------:|
+| **F0** | Models + Fetcher | `models.js`, `fetcher.js`, `config.js` | 1 día |
+| **F1** | **Analyzer (Ollama) — el corazón** | `analyzer.js`, prompt template | 2-3 días |
+| **F2** | Executor básico (main-content + og + jsonld) | `executor.js`, `extract-content.js`, `extract-og.js`, `extract-jsonld.js` | 3-4 días |
+| **F3** | Extractores avanzados (images, tables, cards, forms) | `extract-images.js`, `extract-tables.js`, `extract-cards.js`, `extract-forms.js` | 3-4 días |
+| **F4** | Post-processor + integración knowledge/embeddings | `postprocessor.js`, refactor `opl-webscrape.js` | 2 días |
+| **F5** | Headless browser (Playwright opcional) | `fetcher.js` (modo headless), `extract-special.js` | 2 días |
+| **F6** | Tests + documentación + CLI flags | tests, docs, `commands-opl.js` | 2 días |
+
+**Total estimado:** 2-3 semanas (trabajo parcial, OLLAMA-first)
+
+---
+
+## 7. Beneficios Clave del Enfoque IA
+
+| Aspecto | Readability.js | Scraper Python hardcoded | **Ollama-driven (esta propuesta)** |
+|---------|:--------------:|:------------------------:|:----------------------------------:|
+| **Adaptabilidad** | Solo artículos | Media (reglas fijas) | **Alta (analiza cada página)** |
+| **Clasificación** | No | Heurística | **IA entiende el tipo** |
+| **Metadata** | Mínima | Completa | **Selectiva (solo lo relevante)** |
+| **SPA/JS** | No | Sí (Playwright) | **Sí (Playwright opcional)** |
+| **Mantenimiento** | Nulo | Alto (nuevas reglas) | **Bajo (mejora el prompt)** |
+| **Precisión** | 60-70% | 70-85% | **85-95% (IA entiende contexto)** |
+| **Cobertura** | Blogs/news | Sitios conocidos | **Cualquier página web** |
+| **Dependencias** | Mínimas | Python + librerías | **Node.js + Ollama** |
+
+---
+
+## 8. Riesgos y Mitigaciones
+
+| Riesgo | Probabilidad | Impacto | Mitigación |
+|--------|:------------:|:-------:|------------|
+| Ollama no disponible | Alta | Alto | Fallback automático a Readability.js + Turndown |
+| Prompts largos (>4K tokens) | Media | Medio | Resumir HTML estructuralmente (árbol, no HTML crudo) |
+| Respuesta JSON malformada de Ollama | Media | Medio | Validar JSON + reintentar con `--strict` |
+| Páginas con anti-bot | Media | Alto | Modo headless + User-Agent rotación |
+| Latencia (Ollama analyse = 2-5s) | Alta | Bajo | Cache de planes por dominio + extracción async |
+| Precisión del plan depende del modelo | Alta | Medio | Usar modelos >= 7B (phi-4, llama3.2, qwen2.5) |
+
+---
+
+## 9. Comandos Futuros (Post-F6)
+
+```bash
+# Extracción básica con IA
+opl webscrape https://ejemplo.com
+
+# Solo ver el plan que Ollama generaría (sin extraer)
+opl webscrape https://ejemplo.com --plan-only
+
+# Re-ejecutar con un plan guardado
+opl webscrape https://ejemplo.com --plan ./plan.json
+
+# Crawl completo de un sitio con IA por página
+opl webscrape https://ejemplo.com --crawl --depth 2
+
+# Forzar Playwright para SPAs pesados
+opl webscrape https://spa-ejemplo.com --headless
+
+# Salida JSON para pipeline
+opl webscrape https://ejemplo.com --output json
+
+# Forzar Readability.js (sin IA)
+opl webscrape https://ejemplo.com --simple
+
+# Extraer diseño visual (colores, tipografía, componentes)
+opl webscrape https://ejemplo.com --extract-design
+
+# Ver el prompt que se envía a Ollama
+opl webscrape https://ejemplo.com --debug-prompt
+```
+
+---
+
+## 10. Primeros Pasos Concretos
+
+### Fase 0: Preparación
+
+1. Verificar que Ollama corre localmente:
+   ```bash
+   curl http://localhost:11434/api/tags
+   ```
+
+2. Elegir modelo base (recomendado: `phi-4:14b` o `llama3.2:8b`):
+   ```bash
+   ollama pull phi-4:14b   # Buen balance calidad/velocidad
+   ```
+
+3. Crear estructura de directorios:
+   ```
+   src/core/webscrape/
+   ├── index.js         # Re-export
+   ├── config.js        # Ollama URL, modelo, timeouts
+   ├── models.js        # PageSnapshot, ExtractPlan, ExtractedPage
+   ├── fetcher.js       # node-fetch + Playwright opcional
+   ├── analyzer.js      # Ollama prompt + parseo JSON
+   ├── executor.js      # Ejecuta plan paso a paso
+   ├── postprocessor.js # Markdown + metadata + guardado
+   └── extractors/
+       ├── extract-content.js
+       ├── extract-og.js
+       ├── extract-jsonld.js
+       ├── extract-images.js
+       ├── extract-tables.js
+       └── ...
+   ```
+
+4. Implementar `models.js` + `config.js` + `fetcher.js` (F0, 1 día)
+
+### Fase 1: Analyzer (el corazón)
+
+5. Implementar `analyzer.js`:
+   - Construir resumen estructural del HTML (árbol de secciones, conteo de elementos)
+   - Extraer texto visible (primeros ~2000 chars)
+   - Detectar meta tags OG, Twitter, JSON-LD
+   - Enviar prompt a Ollama (`POST /api/generate`)
+   - Parsear y validar respuesta JSON
+   - Cachear plan por URL en SQLite
+
+6. Probar con 5 tipos de página distintos (article, product, docs, blog, landing)
+
+### Fase 2: Executor básico
+
+7. Implementar extractores core + `executor.js`
+8. Probar end-to-end con `opl webscrape <url>`
+
+---
+
+## 11. Medición de Éxito
+
+| Métrica | Objetivo | Cómo se mide |
+|---------|:--------:|--------------|
+| Precisión del plan | >90% | Validación manual de 50 páginas |
+| Tiempo total por URL | <10s | Benchmark automático |
+| Fallback a Readability | <20% de los casos | Log de modo usado |
+| Tokens por análisis | <3000 | Prompt logging |
+| Cobertura de tipos de página | >80% | Test con 100 URLs diversas |
+| Embeddings generados por scraper | >90% de URLs | Pipeline count |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openprompt-lang",
-  "version": "1.2.7",
+  "version": "1.4.0",
   "description": "PromptLang CLI — Context Engine de anotaciones para desarrollo asistido por IA",
   "type": "module",
   "main": "./bin/cli.js",
@@ -55,7 +55,8 @@
     "opencode:wizard": "openprompt-lang wizard",
     "opencode:plan": "openprompt-lang plan",
     "opencode:execute": "openprompt-lang execute",
-    "opencode:mode": "openprompt-lang mode"
+    "opencode:mode": "openprompt-lang mode",
+    "opl:enforce": "node scripts/opl-enforce-setup.mjs"
   },
   "keywords": [
     "prompt-lang",
@@ -72,14 +73,17 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@mozilla/readability": "^0.6.0",
     "ajv": "^8.20.0",
     "better-sqlite3": "^12.10.0",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "handlebars": "^4.7.9",
     "inquirer": "^9.3.0",
+    "jsdom": "^29.1.1",
     "pdf-parse": "^2.4.5",
     "tesseract.js": "^7.0.0",
+    "turndown": "^7.2.4",
     "typescript": "^6.0.3"
   },
   "devDependencies": {
@@ -105,5 +109,8 @@
     "*.{ts,tsx,js,jsx}": [
       "openprompt-lang lint-file"
     ]
+  },
+  "optionalDependencies": {
+    "@xenova/transformers": "^2.17.2"
   }
 }