npm - better-dsh - Versions diffs - 0.2.5 → 0.3.0 - Mend

better-dsh 0.2.5 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (999) hide show

package/docs/80_upstream-docs-and-skills/hermes-dev-skill/src/docs/user-guide/skills/bundled/productivity/productivity-notion.md DELETED Viewed

@@ -1,463 +0,0 @@
----
-title: "Notion — Notion API + ntn CLI: pages, databases, markdown, Workers"
-sidebar_label: "Notion"
-description: "Notion API + ntn CLI: pages, databases, markdown, Workers"
----
-{/* This page is auto-generated from the skill's SKILL.md by website/scripts/generate-skill-docs.py. Edit the source SKILL.md, not this page. */}
-# Notion
-Notion API + ntn CLI: pages, databases, markdown, Workers.
-## Skill metadata
-| | |
-|---|---|
-| Source | Bundled (installed by default) |
-| Path | `skills/productivity\notion` |
-| Version | `2.0.0` |
-| Author | community |
-| License | MIT |
-| Platforms | linux, macos, windows |
-| Tags | `Notion`, `Productivity`, `Notes`, `Database`, `API`, `CLI`, `Workers` |
-## Reference: full SKILL.md
-:::info
-The following is the complete skill definition that Hermes loads when this skill is triggered. This is what the agent sees as instructions when the skill is active.
-:::
-# Notion
-Talk to Notion two ways. Same integration token works for both — pick by what's available.
-◆ **`ntn` CLI** — Notion's official CLI. Shorter syntax, one-line file uploads, required for Workers. macOS + Linux only as of May 2026 (Windows support "coming soon"). **Default when installed.**
-◆ **HTTP + curl** — works everywhere including Windows. **Default fallback** when `ntn` isn't installed.
-## Setup
-### 1. Get an integration token (required for both paths)
-1. Create an integration at https://notion.so/my-integrations
-2. Copy the API key (starts with `ntn_` or `secret_`)
-3. Store in `${HERMES_HOME:-~/.hermes}/.env`:
-   ```
-   NOTION_API_KEY=ntn_your_key_here
-   ```
-4. **Share target pages/databases with the integration** in Notion: page menu `...` → `Connect to` → your integration name. Without this, the API returns 404 for that page even though it exists.
-### 2. Install `ntn` (preferred path on macOS / Linux)
-```bash
-# Recommended
-curl -fsSL https://ntn.dev | bash
-# Or via npm (needs Node 22+, npm 10+)
-npm install --global ntn
-ntn --version    # verify
-```
-**Skip `ntn login` — use the integration token instead.** This works headlessly, no browser needed:
-```bash
-export NOTION_API_TOKEN=$NOTION_API_KEY      # ntn reads NOTION_API_TOKEN
-export NOTION_KEYRING=0                       # don't try to use the OS keychain
-```
-Add those exports to your shell profile (or to `${HERMES_HOME:-~/.hermes}/.env`) so every session inherits them.
-### 3. Choose path at runtime
-```bash
-if command -v ntn >/dev/null 2>&1; then
-  # use ntn
-else
-  # fall back to curl
-fi
-```
-Windows users: skip step 2 entirely until native `ntn` ships — Path B works fine. If you want CLI ergonomics now, install `ntn` inside WSL2.
-## API Basics
-`Notion-Version: 2025-09-03` is required on all HTTP requests. `ntn` handles this for you. In this version, what users call "databases" are called **data sources** in the API.
-## Path A — `ntn` CLI (preferred, macOS / Linux)
-### Raw API calls (shorthand for curl)
-```bash
-ntn api v1/users                                  # GET
-ntn api v1/pages parent[page_id]=abc123 \         # POST with inline body
-  properties[title][0][text][content]="Notes"
-ntn api v1/pages/abc123 -X PATCH archived:=true   # PATCH; := is non-string (bool/num/null)
-```
-Syntax notes:
-- `key=value` — string fields
-- `key[nested]=value` — nested object fields
-- `key:=value` — typed assignment (booleans, numbers, null, arrays)
-### Search
-```bash
-ntn api v1/search query="page title"
-```
-### Read page metadata
-```bash
-ntn api v1/pages/{page_id}
-```
-### Read page as Markdown (agent-friendly)
-```bash
-ntn api v1/pages/{page_id}/markdown
-```
-### Read page content as blocks
-```bash
-ntn api v1/blocks/{page_id}/children
-```
-### Create page from Markdown
-```bash
-ntn api v1/pages \
-  parent[page_id]=xxx \
-  properties[title][0][text][content]="Notes from meeting" \
-  markdown="# Agenda
-- Q3 roadmap
-- Hiring"
-```
-### Patch a page with Markdown
-```bash
-ntn api v1/pages/{page_id}/markdown -X PATCH \
-  markdown="## Update
-Shipped the prototype."
-```
-### Query a database (data source)
-```bash
-ntn api v1/data_sources/{data_source_id}/query -X POST \
-  filter[property]=Status filter[select][equals]=Active
-```
-For complex queries with `sorts`, multiple filter clauses, or compound logic, pipe JSON in:
-```bash
-echo '{"filter": {"property": "Status", "select": {"equals": "Active"}}, "sorts": [{"property": "Date", "direction": "descending"}]}' | \
-  ntn api v1/data_sources/{data_source_id}/query -X POST --json -
-```
-### File uploads (one-liner — biggest CLI win)
-```bash
-ntn files create < photo.png
-ntn files create --external-url https://example.com/photo.png
-ntn files list
-```
-Compare to the 3-step HTTP flow (create upload → PUT bytes → reference).
-### Useful env vars
-| Var | Effect |
-|---|---|
-| `NOTION_API_TOKEN` | Auth token (overrides keychain) — set this to your integration token |
-| `NOTION_KEYRING=0` | File-based creds at `~/.config/notion/auth.json` instead of OS keychain |
-| `NOTION_WORKSPACE_ID` | Skip the workspace picker prompt |
-## Path B — HTTP + curl (cross-platform, default on Windows)
-All requests share this pattern:
-```bash
-curl -s -X GET "https://api.notion.com/v1/..." \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json"
-```
-On Windows the `curl` shipped with Windows 10+ works as-is. PowerShell users can also use `Invoke-RestMethod`.
-### Search
-```bash
-curl -s -X POST "https://api.notion.com/v1/search" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json" \
-  -d '{"query": "page title"}'
-```
-### Read page metadata
-```bash
-curl -s "https://api.notion.com/v1/pages/{page_id}" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03"
-```
-### Read page as Markdown (agent-friendly)
-Easier to feed to a model than block JSON.
-```bash
-curl -s "https://api.notion.com/v1/pages/{page_id}/markdown" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03"
-```
-### Read page content as blocks (when you need structure)
-```bash
-curl -s "https://api.notion.com/v1/blocks/{page_id}/children" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03"
-```
-### Create page from Markdown
-`POST /v1/pages` accepts a `markdown` body param.
-```bash
-curl -s -X POST "https://api.notion.com/v1/pages" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "parent": {"page_id": "xxx"},
-    "properties": {"title": [{"text": {"content": "Notes from meeting"}}]},
-    "markdown": "# Agenda\n\n- Q3 roadmap\n- Hiring\n\n## Decisions\n- Ship MVP Friday"
-  }'
-```
-### Patch a page with Markdown
-```bash
-curl -s -X PATCH "https://api.notion.com/v1/pages/{page_id}/markdown" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json" \
-  -d '{"markdown": "## Update\n\nShipped the prototype."}'
-```
-### Create page in a database (typed properties)
-```bash
-curl -s -X POST "https://api.notion.com/v1/pages" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "parent": {"database_id": "xxx"},
-    "properties": {
-      "Name": {"title": [{"text": {"content": "New Item"}}]},
-      "Status": {"select": {"name": "Todo"}}
-    }
-  }'
-```
-### Query a database (data source)
-```bash
-curl -s -X POST "https://api.notion.com/v1/data_sources/{data_source_id}/query" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "filter": {"property": "Status", "select": {"equals": "Active"}},
-    "sorts": [{"property": "Date", "direction": "descending"}]
-  }'
-```
-### Create a database
-```bash
-curl -s -X POST "https://api.notion.com/v1/data_sources" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "parent": {"page_id": "xxx"},
-    "title": [{"text": {"content": "My Database"}}],
-    "properties": {
-      "Name": {"title": {}},
-      "Status": {"select": {"options": [{"name": "Todo"}, {"name": "Done"}]}},
-      "Date": {"date": {}}
-    }
-  }'
-```
-### Update page properties
-```bash
-curl -s -X PATCH "https://api.notion.com/v1/pages/{page_id}" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json" \
-  -d '{"properties": {"Status": {"select": {"name": "Done"}}}}'
-```
-### Append blocks to a page
-```bash
-curl -s -X PATCH "https://api.notion.com/v1/blocks/{page_id}/children" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "children": [
-      {"object": "block", "type": "paragraph", "paragraph": {"rich_text": [{"text": {"content": "Hello from Hermes!"}}]}}
-    ]
-  }'
-```
-### File uploads (3-step flow)
-```bash
-# 1. Create upload
-curl -s -X POST "https://api.notion.com/v1/file_uploads" \
-  -H "Authorization: Bearer $NOTION_API_KEY" \
-  -H "Notion-Version: 2025-09-03" \
-  -H "Content-Type: application/json" \
-  -d '{"filename": "photo.png", "content_type": "image/png"}'
-# 2. PUT bytes to the upload_url returned above
-curl -s -X PUT "{upload_url}" --data-binary @photo.png
-# 3. Reference {file_upload_id} in a page/block payload
-```
-## Property Types
-Common property formats for database items:
-- **Title:** `{"title": [{"text": {"content": "..."}}]}`
-- **Rich text:** `{"rich_text": [{"text": {"content": "..."}}]}`
-- **Select:** `{"select": {"name": "Option"}}`
-- **Multi-select:** `{"multi_select": [{"name": "A"}, {"name": "B"}]}`
-- **Date:** `{"date": {"start": "2026-01-15", "end": "2026-01-16"}}`
-- **Checkbox:** `{"checkbox": true}`
-- **Number:** `{"number": 42}`
-- **URL:** `{"url": "https://..."}`
-- **Email:** `{"email": "user@example.com"}`
-- **Relation:** `{"relation": [{"id": "page_id"}]}`
-## API Version 2025-09-03 — Databases vs Data Sources
-- **Databases became data sources.** Use `/data_sources/` endpoints for queries and retrieval.
-- **Two IDs per database:** `database_id` and `data_source_id`.
-  - `database_id` when creating pages: `parent: {"database_id": "..."}`
-  - `data_source_id` when querying: `POST /v1/data_sources/{id}/query`
-- Search returns databases as `"object": "data_source"` with the `data_source_id` field.
-## Notion Workers (advanced, requires `ntn`)
-Workers are TypeScript programs Notion hosts for you. One worker can expose any combination of:
-- **Syncs** — pull data from external APIs into a Notion database on a schedule (default 30 min).
-- **Tools** — appear as callable tools inside Notion's Custom Agents.
-- **Webhooks** — receive HTTP events from external services (GitHub, Stripe, etc.) and act in Notion.
-**Plan / platform gating:**
-- CLI works on all plans. **Deploying Workers requires Business or Enterprise.**
-- `ntn` is macOS/Linux only as of May 2026. Windows users need WSL2 or to wait for native support.
-- Free through August 11, 2026; metered on Notion credits after.
-### Minimal Worker
-```bash
-ntn workers new my-worker      # scaffold
-cd my-worker
-# Edit src/index.ts
-ntn workers deploy --name my-worker
-```
-`src/index.ts`:
-```typescript
-import { Worker } from "@notionhq/workers";
-const worker = new Worker();
-export default worker;
-worker.tool("greet", {
-  title: "Greet a User",
-  description: "Returns a friendly greeting",
-  inputSchema: { type: "object", properties: { name: { type: "string" } }, required: ["name"] },
-  execute: async ({ name }) => `Hello, ${name}!`,
-});
-```
-### Webhook capability
-```typescript
-worker.webhook("onGithubPush", {
-  title: "GitHub Push Handler",
-  execute: async (events, { notion }) => {
-    for (const event of events) {
-      // event.body, event.rawBody (for signature verification), event.headers
-      console.log("got delivery", event.deliveryId);
-    }
-  },
-});
-```
-After deploy: `ntn workers webhooks list` shows the URL Notion generates. Treat that URL as a secret — anyone with it can POST events unless you add signature verification.
-### Worker lifecycle commands
-```bash
-ntn workers deploy
-ntn workers list
-ntn workers exec <capability-key> -d '{"name": "world"}'
-ntn workers sync trigger <key>            # run a sync now
-ntn workers sync pause <key>
-ntn workers env set GITHUB_WEBHOOK_SECRET=...
-ntn workers runs list                     # recent invocations
-ntn workers runs logs <run-id>
-ntn workers webhooks list
-```
-When asked to build a Worker, scaffold with `ntn workers new`, write the code in `src/index.ts`, set any secrets with `ntn workers env set`, and deploy. Notion's docs at https://developers.notion.com/workers cover the full API surface.
-## Notion-Flavored Markdown (used by `/markdown` endpoints)
-Standard CommonMark plus XML-like tags for Notion-specific blocks. Use **tabs** for indentation.
-**Blocks beyond CommonMark:**
-```
-<callout icon="🎯" color="blue_bg">
-	Ship the MVP by **Friday**.
-</callout>
-<details color="gray">
-<summary>Toggle title</summary>
-	Children indented one tab
-</details>
-<columns>
-	<column>Left side</column>
-	<column>Right side</column>
-</columns>
-<table_of_contents color="gray"/>
-```
-**Inline:**
-- Mentions: `<mention-user url="..."/>`, `<mention-page url="...">Title</mention-page>`, `<mention-date start="2026-05-15"/>`
-- Underline: `<span underline="true">text</span>`
-- Color: `<span color="blue">text</span>` or block-level `{color="blue"}` on the first line
-- Math: inline `$x^2$`, block `$$ ... $$`
-- Citations: `[^https://example.com]`
-**Colors:** `gray brown orange yellow green blue purple pink red`, plus `*_bg` variants for backgrounds.
-Headings 5/6 collapse to H4. Multiple `>` lines render as separate quote blocks — use `<br>` inside a single `>` for multi-line quotes.
-## Choosing the Right Path
-| Task | mac / Linux | Windows |
-|---|---|---|
-| Read/write pages, search, query databases | `ntn api ...` | curl |
-| Read a page for an agent to summarize | `ntn api v1/pages/{id}/markdown` | curl `/markdown` endpoint |
-| Upload a file | `ntn files create < file` | 3-step HTTP flow |
-| One-off API exploration | `ntn api ...` | curl |
-| Build a sync / webhook / agent tool hosted by Notion | `ntn workers ...` | WSL2 + `ntn workers ...` |
-## Notes
-- Page/database IDs are UUIDs (with or without dashes — both accepted).
-- Rate limit: ~3 requests/second average. The CLI doesn't bypass this.
-- The API cannot set database **view** filters — that's UI-only.
-- Use `"is_inline": true` when creating data sources to embed them in a page.
-- Always pass `-s` to curl to suppress progress bars (cleaner agent output).
-- Pipe JSON through `jq` when reading: `... | jq '.results[0].properties'`.
-- Notion also ships an MCP server now (`Notion MCP`, ~91% more token-efficient on DB ops than the previous version) — wire it via Hermes' MCP support if you want streaming Notion access from inside a session, but the paths above are enough for most one-shot tasks.

package/docs/80_upstream-docs-and-skills/hermes-dev-skill/src/docs/user-guide/skills/bundled/productivity/productivity-ocr-and-documents.md DELETED Viewed

@@ -1,193 +0,0 @@
----
-title: "Ocr And Documents — Extract text from PDFs/scans (pymupdf, marker-pdf)"
-sidebar_label: "Ocr And Documents"
-description: "Extract text from PDFs/scans (pymupdf, marker-pdf)"
----
-{/* This page is auto-generated from the skill's SKILL.md by website/scripts/generate-skill-docs.py. Edit the source SKILL.md, not this page. */}
-# Ocr And Documents
-Extract text from PDFs/scans (pymupdf, marker-pdf).
-## Skill metadata
-| | |
-|---|---|
-| Source | Bundled (installed by default) |
-| Path | `skills/productivity/ocr-and-documents` |
-| Version | `2.3.0` |
-| Author | Hermes Agent |
-| License | MIT |
-| Platforms | linux, macos, windows |
-| Tags | `PDF`, `Documents`, `Research`, `Arxiv`, `Text-Extraction`, `OCR` |
-| Related skills | [`pdf`](/docs/user-guide/skills/bundled/productivity/productivity-pdf), [`docx`](/docs/user-guide/skills/bundled/productivity/productivity-docx), [`powerpoint`](/docs/user-guide/skills/bundled/productivity/productivity-powerpoint) |
-## Reference: full SKILL.md
-:::info
-The following is the complete skill definition that Hermes loads when this skill is triggered. This is what the agent sees as instructions when the skill is active.
-:::
-# PDF & Document Extraction
-For DOCX: see the `docx` skill (create/edit) or use `python-docx` for structured reads.
-For PPTX: see the `powerpoint` skill (full create/read/edit support).
-For PDF manipulation (merge, split, forms, watermarks, creation): see the `pdf` skill.
-This skill covers **text extraction from PDFs and scanned documents**.
-> **Coming from a `read_file` EXTRACTION COVERAGE WARNING?** `read_file` auto-converts local PDFs but reads the text layer only; the warning footer lists the pages that yielded no text (scanned images). For a handful of pages, render + vision is fastest: `pdftoppm -jpeg -r 150 -f N -l N file.pdf /tmp/page` then `vision_analyze` each image. For bulk OCR of many pages, use marker-pdf below (Step 2).
-## Step 1: Remote URL Available?
-If the document has a URL, **always try `web_extract` first**:
-```
-web_extract(urls=["https://arxiv.org/pdf/2402.03300"])
-web_extract(urls=["https://example.com/report.pdf"])
-```
-This handles PDF-to-markdown conversion via Firecrawl with no local dependencies.
-Only use local extraction when: the file is local, web_extract fails, or you need batch processing.
-## Step 2: Choose Local Extractor
-| Feature | pymupdf (~25MB) | marker-pdf (~3-5GB) |
-|---------|-----------------|---------------------|
-| **Text-based PDF** | ✅ | ✅ |
-| **Scanned PDF (OCR)** | ❌ | ✅ (90+ languages) |
-| **Tables** | ✅ (basic) | ✅ (high accuracy) |
-| **Equations / LaTeX** | ❌ | ✅ |
-| **Code blocks** | ❌ | ✅ |
-| **Forms** | ❌ | ✅ |
-| **Headers/footers removal** | ❌ | ✅ |
-| **Reading order detection** | ❌ | ✅ |
-| **Images extraction** | ✅ (embedded) | ✅ (with context) |
-| **Images → text (OCR)** | ❌ | ✅ |
-| **EPUB** | ✅ | ✅ |
-| **Markdown output** | ✅ (via pymupdf4llm) | ✅ (native, higher quality) |
-| **Install size** | ~25MB | ~3-5GB (PyTorch + models) |
-| **Speed** | Instant | ~1-14s/page (CPU), ~0.2s/page (GPU) |
-**Decision**: Use pymupdf unless you need OCR, equations, forms, or complex layout analysis.
-If the user needs marker capabilities but the system lacks ~5GB free disk:
-> "This document needs OCR/advanced extraction (marker-pdf), which requires ~5GB for PyTorch and models. Your system has [X]GB free. Options: free up space, provide a URL so I can use web_extract, or I can try pymupdf which works for text-based PDFs but not scanned documents or equations."
----
-## pymupdf (lightweight)
-```bash
-pip install pymupdf pymupdf4llm
-```
-**Via helper script**:
-```bash
-python scripts/extract_pymupdf.py document.pdf              # Plain text
-python scripts/extract_pymupdf.py document.pdf --markdown    # Markdown
-python scripts/extract_pymupdf.py document.pdf --tables      # Tables
-python scripts/extract_pymupdf.py document.pdf --images out/ # Extract images
-python scripts/extract_pymupdf.py document.pdf --metadata    # Title, author, pages
-python scripts/extract_pymupdf.py document.pdf --pages 0-4   # Specific pages
-```
-**Inline**:
-```bash
-python3 -c "
-import pymupdf
-doc = pymupdf.open('document.pdf')
-for page in doc:
-    print(page.get_text())
-"
-```
----
-## marker-pdf (high-quality OCR)
-```bash
-# Check disk space first
-python scripts/extract_marker.py --check
-pip install marker-pdf
-```
-**Via helper script**:
-```bash
-python scripts/extract_marker.py document.pdf                # Markdown
-python scripts/extract_marker.py document.pdf --json         # JSON with metadata
-python scripts/extract_marker.py document.pdf --output_dir out/  # Save images
-python scripts/extract_marker.py scanned.pdf                 # Scanned PDF (OCR)
-python scripts/extract_marker.py document.pdf --use_llm      # LLM-boosted accuracy
-```
-**CLI** (installed with marker-pdf):
-```bash
-marker_single document.pdf --output_dir ./output
-marker /path/to/folder --workers 4    # Batch
-```
----
-## Arxiv Papers
-```
-# Abstract only (fast)
-web_extract(urls=["https://arxiv.org/abs/2402.03300"])
-# Full paper
-web_extract(urls=["https://arxiv.org/pdf/2402.03300"])
-# Search
-web_search(query="arxiv GRPO reinforcement learning 2026")
-```
-## Split, Merge & Search
-pymupdf handles these natively — use `execute_code` or inline Python:
-```python
-# Split: extract pages 1-5 to a new PDF
-import pymupdf
-doc = pymupdf.open("report.pdf")
-new = pymupdf.open()
-for i in range(5):
-    new.insert_pdf(doc, from_page=i, to_page=i)
-new.save("pages_1-5.pdf")
-```
-```python
-# Merge multiple PDFs
-import pymupdf
-result = pymupdf.open()
-for path in ["a.pdf", "b.pdf", "c.pdf"]:
-    result.insert_pdf(pymupdf.open(path))
-result.save("merged.pdf")
-```
-```python
-# Search for text across all pages
-import pymupdf
-doc = pymupdf.open("report.pdf")
-for i, page in enumerate(doc):
-    results = page.search_for("revenue")
-    if results:
-        print(f"Page {i+1}: {len(results)} match(es)")
-        print(page.get_text("text"))
-```
-No extra dependencies needed — pymupdf covers split, merge, search, and text extraction in one package.
----
-## Notes
-- `web_extract` is always first choice for URLs
-- pymupdf is the safe default — instant, no models, works everywhere
-- marker-pdf is for OCR, scanned docs, equations, complex layouts — install only when needed
-- Both helper scripts accept `--help` for full usage
-- marker-pdf downloads ~2.5GB of models to `~/.cache/huggingface/` on first use
-- For Word docs: `pip install python-docx` (better than OCR — parses actual structure)
-- For PowerPoint: see the `powerpoint` skill (uses python-pptx)