openprompt-lang 1.2.7 → 1.3.0

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.3.0",
   "description": "PromptLang CLI — Context Engine de anotaciones para desarrollo asistido por IA",
   "type": "module",
   "main": "./bin/cli.js",
@@ -72,14 +72,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 +108,8 @@
     "*.{ts,tsx,js,jsx}": [
       "openprompt-lang lint-file"
     ]
+  },
+  "optionalDependencies": {
+    "@xenova/transformers": "^2.17.2"
   }
 }

package/scripts/postinstall.js

@@ -90,6 +90,43 @@ try {
         console.log("  💡 O instálalo manualmente según tu plataforma.")
       }
     }
+    // ──────────────────────────────────────────────
+    // Información sobre embeddings y Ollama
+    // ──────────────────────────────────────────────
+    try {
+      const { execSync } = await import("child_process")
+      const ollamaPath = execSync("which ollama 2>/dev/null || echo ''", {
+        encoding: "utf-8",
+      }).trim()
+
+      if (ollamaPath) {
+        const models = execSync("ollama list 2>/dev/null || echo ''", {
+          encoding: "utf-8",
+        }).trim()
+        const hasEmbedModel = models.toLowerCase().includes("nomic-embed-text")
+
+        if (hasEmbedModel) {
+          console.log("✅ Ollama + nomic-embed-text listos para embeddings semánticos")
+        } else {
+          console.log("📦 Ollama detectado. Para embeddings semánticos ejecuta:")
+          console.log("     ollama pull nomic-embed-text")
+        }
+      } else {
+        console.log("📦 Ollama no detectado. Usando Transformers.js como fallback.")
+        console.log("   💡 Instala Ollama para mejor rendimiento: https://ollama.com")
+        console.log("   💡 Luego: ollama pull nomic-embed-text")
+      }
+    } catch {
+      // No crítico
+    }
+
+    console.log("")
+    console.log("🔍  Búsqueda semántica disponible:")
+    console.log('     opl search "consulta" --mode vector')
+    console.log("")
+    console.log("📊  Indexa documentos en el vector store:")
+    console.log("     opl embeddings index <docId>")
+    console.log("")
     console.log("💡 Ejecuta 'opl init' para crear un nuevo proyecto con planificación")
   } catch (err) {
     console.log(`  ⚠️  opencode: ${err.message}`)

package/src/cli/commands-knowledge.js

@@ -23,6 +23,7 @@ export function register(program) {
     .option("--auto-ocr", "Detectar automáticamente si necesita OCR (baja densidad de texto)")
     .option("--force", "Re-procesar PDF aunque ya exista en el índice")
     .option("--verbose", "Mostrar progreso detallado (especialmente OCR)")
+    .option("--no-embed", "Saltar la generación automática de embeddings")
     .action(async (file, options) => {
       const { ingest } = await import("../commands/knowledge.js")
       await ingest(file, options)

package/src/cli/commands-opl.js

@@ -61,7 +61,7 @@ export function register(program) {
     .command("search <query>")
     .description("Buscar en el conocimiento: tags + texto completo + semántica")
     .usage("<consulta>")
-    .option("--mode <mode>", "Modo de búsqueda: tags, fulltext, semantic, hybrid (default)")
+    .option("--mode <mode>", "Modo de búsqueda: tags, fulltext, semantic, vector, hybrid (default)")
     .action(async (query, options) => {
       const { search } = await import("../commands/opl-search.js")
       await search(query, options)
@@ -249,6 +249,84 @@ export function register(program) {
       await contractSearch(query)
     })
 
+  // ──────────────────────────────────────────────
+  // opl embeddings — Gestión de vectores de embeddings
+  // ──────────────────────────────────────────────
+  const embeddings = program
+    .command("embeddings")
+    .description("Gestionar embeddings vectoriales: indexar, consultar estado, eliminar")
+
+  embeddings
+    .command("index [docId]")
+    .description("Indexar un documento: chunking → embedding → almacenamiento vectorial")
+    .usage("<docId>")
+    .option("--strategy <s>", "Estrategia de chunking: section, paragraph, fixed", "section")
+    .option("--provider <p>", "Proveedor de embeddings: ollama, transformers")
+    .option("--dry-run", "Simular indexación sin persistir")
+    .option("--resume", "Saltar chunks ya indexados")
+    .action(async (docId, options) => {
+      const { embeddings } = await import("../commands/opl-embeddings.js")
+      await embeddings("index", { ...options, docId })
+    })
+
+  embeddings
+    .command("status")
+    .description("Mostrar estado del índice de embeddings")
+    .action(async () => {
+      const { embeddings } = await import("../commands/opl-embeddings.js")
+      await embeddings("status")
+    })
+
+  embeddings
+    .command("remove <docId>")
+    .description("Eliminar embeddings de un documento")
+    .usage("<docId>")
+    .action(async (docId) => {
+      const { embeddings } = await import("../commands/opl-embeddings.js")
+      await embeddings("remove", { docId })
+    })
+
+  embeddings
+    .command("config")
+    .description("Ver o configurar el proveedor de embeddings")
+    .option("--provider <p>", "Establecer proveedor: ollama, transformers")
+    .action(async (options) => {
+      const { embeddings } = await import("../commands/opl-embeddings.js")
+      await embeddings("config", options)
+    })
+
+  // ──────────────────────────────────────────────
+  // opl webscrape — Extraer contenido web e indexar
+  // ──────────────────────────────────────────────
+  program
+    .command("webscrape <url>")
+    .description("Extraer contenido de una web, guardarlo como conocimiento e indexar embeddings")
+    .usage("<url>")
+    .option("--domain <d>", "Dominio de conocimiento destino (default: web)")
+    .option("--no-embed", "No indexar embeddings automáticamente")
+    .option("--clean", "Limpiar contenido con Ollama")
+    .option("--deep", "Deep scrape: navega categorías y subcategorías recursivamente")
+    .option("--max-depth <n>", "Profundidad máxima para deep scrape (default: 2)", parseInt)
+    .option("--concurrency <n>", "Fetchs simultáneos para deep scrape (default: 3)", parseInt)
+    .option("--verbose", "Log detallado del proceso")
+    .option("--no-ollama", "No usar Ollama para analizar páginas (solo heurísticas)")
+    .action(async (url, options) => {
+      if (options.deep) {
+        const { deepScrape } = await import("../core/webscrape/deep-scraper.js")
+        await deepScrape(url, {
+          maxDepth: options.maxDepth || 2,
+          concurrency: options.concurrency || 3,
+          domain: options.domain || "web",
+          noEmbed: options.noEmbed === true,
+          verbose: options.verbose === true,
+          ollama: options.ollama !== false, // default: true
+        })
+      } else {
+        const { webscrape } = await import("../commands/opl-webscrape.js")
+        await webscrape(url, options)
+      }
+    })
+
   // ──────────────────────────────────────────────
   // opl upgrade — Actualizar config a versión actual
   // ──────────────────────────────────────────────