office-worker-mcp 0.1.0__tar.gz

office_worker_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julio Cardozo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

office_worker_mcp-0.1.0/NOTICE

@@ -0,0 +1,13 @@
+# Acknowledgements
+
+`office-worker-mcp` was designed and built independently by Julio Cardozo.
+
+During its development, the following MIT-licensed project was used as a **read-only
+reference** for MCP server structure and tool design patterns (no code was copied
+verbatim; it informed architectural decisions only):
+
+- **gawirable/office-mcp** — https://github.com/gawirable/office-mcp (MIT License)
+
+All other functionality (template engine with variables, corporate theme system,
+PDF-as-input reading/extraction, editable PPTX generation, anti-loop guidance) is
+original work of this repository.

office_worker_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: office-worker-mcp
+Version: 0.1.0
+Summary: The Office Worker — your agent's document clerk: Word, Excel, PowerPoint & PDF with real design (templates + themes + PDF input).
+Author: Julio Cardozo
+License: MIT
+Keywords: mcp,office,pdf,docx,xlsx,pptx,documents,agent,templates
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: mcp[cli]<2,>=1.27
+Requires-Dist: python-docx>=1.0
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: python-pptx>=1.0
+Requires-Dist: weasyprint>=60
+Requires-Dist: jinja2>=3.1
+Requires-Dist: PyMuPDF>=1.24
+Requires-Dist: pdfplumber>=0.11
+Requires-Dist: pypdf>=4
+Provides-Extra: pptx
+Requires-Dist: html-to-pptx>=0.3; extra == "pptx"
+Requires-Dist: playwright>=1.40; extra == "pptx"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: html-to-pptx>=0.3; extra == "dev"
+Requires-Dist: playwright>=1.40; extra == "dev"
+Dynamic: license-file
+
+# The Office Worker — `office-worker-mcp`
+
+> **Your agent's document clerk.** Genera documentos de oficina profesionales —
+> **PDF, Word, Excel y PowerPoint** — desde datos + un tema corporativo, y lee PDFs
+> (texto, tablas y formularios). Diseñado para agentes de IA (Hermes, Claude, Cursor)
+> vía [MCP](https://modelcontextprotocol.io), 100% local-first.
+
+```
+pip install office-worker-mcp          # instala librería + MCP server + CLI 'owi'
+```
+
+Conectalo a tu agente (ejemplo config MCP / stdio):
+
+```json
+{ "mcpServers": { "office-worker": { "command": "office-worker-mcp" } } }
+```
+
+Y listo: le pedís *"haceme una factura/informe/deck"* en lenguaje natural y tu agente
+usa las tools del oficinista para producir el archivo bien diseñado.
+
+## Por qué existe (diferenciadores)
+
+Los MCPs de documentos existentes son CRUD genéricos (47+ tools que inflan el contexto)
+y no cubren diseño ni PDF como entrada. El Office Worker hace lo contrario:
+
+| | office-mcp / takos | **The Office Worker** |
+|---|---|---|
+| Tools | ~47–80 CRUD genéricas | **8 poderosas** (~2K tok/turno vs ~6.4K) |
+| Plantillas con variables | ❌ | ✅ Jinja (`{{ var }}`) |
+| Temas corporativos (paleta/fuente) | ❌ parámetros sueltos | ✅ aplicable de una vez a todos los formatos |
+| PDF como **input** (leer/tablas/formularios) | ❌ | ✅ PyMuPDF + pdfplumber + pypdf |
+| PPTX **editable** (textos nativos, no imágenes) | parcial | ✅ html-to-pptx verificado |
+| Guía anti-loop para agentes | ❌ | ✅ SKILL.md con reglas probadas en producción |
+
+## Las 8 tools
+
+| Tool | Qué hace |
+|---|---|
+| `render_document` | PDF profesional desde plantilla HTML/Jinja + datos + tema (WeasyPrint) |
+| `create_word` | `.docx` con h1/h2/párrafos/tablas, tema aplicado (python-docx) |
+| `create_excel` | `.xlsx` multi-hoja con paleta y filas alternas (openpyxl) |
+| `create_pptx` | `.pptx` **editable** desde slides declarativas (html-to-pptx + Playwright) |
+| `read_pdf` | Extrae texto por página + metadatos de un PDF (input) |
+| `pdf_extract_tables` | Tablas estructuradas de un PDF (pdfplumber) |
+| `pdf_list_form_fields` | Campos de formulario AcroForm de un PDF (pypdf) |
+| `list_themes` | Devuelve la paleta/fuente del tema activo como referencia de diseño |
+
+## Uso rápido (sin agente, vía CLI o Python)
+
+```python
+from office_worker.core import create_word, create_excel, render_pdf
+
+create_word("acta.docx", title="Acta", subtitle="Reunión", blocks=[
+    {"type":"h2","text":"Puntos"}, {"type":"p","text":"Decisión tomada"}])
+
+create_excel("balance.xlsx", title="Balance", sheets=[{"name":"Resumen",
+    "headers":["Rubro","Monto"],"rows":[["Ingresos",100],["Gastos",40]]}])
+```
+
+## Requisitos locales
+
+- Python ≥ 3.9 · WeasyPrint (necesita fontconfig/pango en Linux) · LibreOffice opcional.
+- **PPTX editable** (opcional): `pip install office-worker-mcp[pptx]` + `playwright install chromium`.
+  Sin este extra, las tools de PDF/Word/Excel funcionan igual; solo `create_pptx` queda deshabilitada.
+- Todo corre en local; sin cloud.
+
+## Desarrollo & tests
+
+```bash
+pip install -e ".[dev]"
+pytest            # test_core.py (núcleo) + test_e2e_mcp.py (MCP end-to-end, 8/8 tools)
+```
+
+El test E2E levanta el servidor MCP real, hace handshake y ejecuta cada tool creando/leyendo archivos válidos en disco.
+
+## Licencia
+
+MIT — ver [LICENSE](LICENSE). Agradecimientos en [NOTICE](NOTICE).

office_worker_mcp-0.1.0/README.md

@@ -0,0 +1,78 @@
+# The Office Worker — `office-worker-mcp`
+
+> **Your agent's document clerk.** Genera documentos de oficina profesionales —
+> **PDF, Word, Excel y PowerPoint** — desde datos + un tema corporativo, y lee PDFs
+> (texto, tablas y formularios). Diseñado para agentes de IA (Hermes, Claude, Cursor)
+> vía [MCP](https://modelcontextprotocol.io), 100% local-first.
+
+```
+pip install office-worker-mcp          # instala librería + MCP server + CLI 'owi'
+```
+
+Conectalo a tu agente (ejemplo config MCP / stdio):
+
+```json
+{ "mcpServers": { "office-worker": { "command": "office-worker-mcp" } } }
+```
+
+Y listo: le pedís *"haceme una factura/informe/deck"* en lenguaje natural y tu agente
+usa las tools del oficinista para producir el archivo bien diseñado.
+
+## Por qué existe (diferenciadores)
+
+Los MCPs de documentos existentes son CRUD genéricos (47+ tools que inflan el contexto)
+y no cubren diseño ni PDF como entrada. El Office Worker hace lo contrario:
+
+| | office-mcp / takos | **The Office Worker** |
+|---|---|---|
+| Tools | ~47–80 CRUD genéricas | **8 poderosas** (~2K tok/turno vs ~6.4K) |
+| Plantillas con variables | ❌ | ✅ Jinja (`{{ var }}`) |
+| Temas corporativos (paleta/fuente) | ❌ parámetros sueltos | ✅ aplicable de una vez a todos los formatos |
+| PDF como **input** (leer/tablas/formularios) | ❌ | ✅ PyMuPDF + pdfplumber + pypdf |
+| PPTX **editable** (textos nativos, no imágenes) | parcial | ✅ html-to-pptx verificado |
+| Guía anti-loop para agentes | ❌ | ✅ SKILL.md con reglas probadas en producción |
+
+## Las 8 tools
+
+| Tool | Qué hace |
+|---|---|
+| `render_document` | PDF profesional desde plantilla HTML/Jinja + datos + tema (WeasyPrint) |
+| `create_word` | `.docx` con h1/h2/párrafos/tablas, tema aplicado (python-docx) |
+| `create_excel` | `.xlsx` multi-hoja con paleta y filas alternas (openpyxl) |
+| `create_pptx` | `.pptx` **editable** desde slides declarativas (html-to-pptx + Playwright) |
+| `read_pdf` | Extrae texto por página + metadatos de un PDF (input) |
+| `pdf_extract_tables` | Tablas estructuradas de un PDF (pdfplumber) |
+| `pdf_list_form_fields` | Campos de formulario AcroForm de un PDF (pypdf) |
+| `list_themes` | Devuelve la paleta/fuente del tema activo como referencia de diseño |
+
+## Uso rápido (sin agente, vía CLI o Python)
+
+```python
+from office_worker.core import create_word, create_excel, render_pdf
+
+create_word("acta.docx", title="Acta", subtitle="Reunión", blocks=[
+    {"type":"h2","text":"Puntos"}, {"type":"p","text":"Decisión tomada"}])
+
+create_excel("balance.xlsx", title="Balance", sheets=[{"name":"Resumen",
+    "headers":["Rubro","Monto"],"rows":[["Ingresos",100],["Gastos",40]]}])
+```
+
+## Requisitos locales
+
+- Python ≥ 3.9 · WeasyPrint (necesita fontconfig/pango en Linux) · LibreOffice opcional.
+- **PPTX editable** (opcional): `pip install office-worker-mcp[pptx]` + `playwright install chromium`.
+  Sin este extra, las tools de PDF/Word/Excel funcionan igual; solo `create_pptx` queda deshabilitada.
+- Todo corre en local; sin cloud.
+
+## Desarrollo & tests
+
+```bash
+pip install -e ".[dev]"
+pytest            # test_core.py (núcleo) + test_e2e_mcp.py (MCP end-to-end, 8/8 tools)
+```
+
+El test E2E levanta el servidor MCP real, hace handshake y ejecuta cada tool creando/leyendo archivos válidos en disco.
+
+## Licencia
+
+MIT — ver [LICENSE](LICENSE). Agradecimientos en [NOTICE](NOTICE).

office_worker_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "office-worker-mcp"
+version = "0.1.0"
+description = "The Office Worker — your agent's document clerk: Word, Excel, PowerPoint & PDF with real design (templates + themes + PDF input)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Julio Cardozo" }]
+keywords = ["mcp", "office", "pdf", "docx", "xlsx", "pptx", "documents", "agent", "templates"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Office/Business",
+]
+dependencies = [
+    "mcp[cli]>=1.27,<2",
+    "python-docx>=1.0",
+    "openpyxl>=3.1",
+    "python-pptx>=1.0",
+    "weasyprint>=60",
+    "jinja2>=3.1",
+    "PyMuPDF>=1.24",
+    "pdfplumber>=0.11",
+    "pypdf>=4",
+]
+
+# PPTX editable requiere html-to-pptx + Playwright/Chromium (pesado, con navegador).
+# Se declara como extra opcional para no forzar Chromium a quien solo usa PDF/Word/Excel.
+[project.optional-dependencies]
+pptx = ["html-to-pptx>=0.3", "playwright>=1.40"]
+dev = ["pytest>=8", "pytest-asyncio>=0.23", "html-to-pptx>=0.3", "playwright>=1.40"]
+
+[project.scripts]
+# Cara CLI (opcional) para no-tecnicos/scripts; el MCP es la cara principal para agentes IA.
+owi = "office_worker.cli:main"
+# Command del MCP server (stdio) — el que va en la config mcpServers del agente.
+office-worker-mcp = "office_worker.mcp_server:main"
+
+[project.entry-points."mcp.servers"]
+office_worker = "office_worker.mcp_server:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

office_worker_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

office_worker_mcp-0.1.0/src/office_worker/__init__.py

@@ -0,0 +1,5 @@
+"""office_worker — The Office Worker.
+
+Núcleo librería (sin depender de MCP). El wrapper MCP y la CLI son caras delgadas encima.
+"""
+__version__ = "0.1.0"

office_worker_mcp-0.1.0/src/office_worker/cli.py

@@ -0,0 +1,55 @@
+"""Cara CLI mínima ('owi') para scripts/no-tecnicos. El MCP es la cara principal; esto es extra.
+
+Uso:
+  owi pdf --out informe.pdf --title "Informe" --subtitle "Q3" [--theme aden] [--rows "A|1,B|2"]
+  owi word --out acta.docx --title "Acta" [--blocks-json '[{"type":"p","text":"hola"}]']
+  owi excel --out bal.xlsx --title "Balance" [--sheets-json '[{"name":"R","headers":[...],"rows":[...]}]']
+"""
+from __future__ import annotations
+import argparse, json, os, sys
+
+
+def _print(r): print(json.dumps(r, ensure_ascii=False))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="owi", description="The Office Worker — CLI")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    def common(sp):
+        sp.add_argument("--out", required=True); sp.add_argument("--theme", default=None)
+
+    pdf = sub.add_parser("pdf"); common(pdf); pdf.add_argument("--title", default="Documento")
+    pdf.add_argument("--subtitle", default=""); pdf.add_argument("--body", default="")
+    pdf.add_argument("--rows", default="", help="tabla: 'H1|H2' filas separadas por ',' celdas por '|'")
+
+    wd = sub.add_parser("word"); common(wd); wd.add_argument("--title", default="")
+    wd.add_argument("--blocks-json", default="[]")
+
+    ex = sub.add_parser("excel"); common(ex); ex.add_argument("--title", default="")
+    ex.add_argument("--sheets-json", default="[]")
+
+    a = p.parse_args(argv)
+
+    from office_worker.core import render_pdf, create_word, create_excel
+
+    if a.cmd == "pdf":
+        rows=[]; headers=[]
+        if a.rows:
+            parts=a.rows.split(",")
+            headers=parts[0].split("|"); rows=[r.split("|") for r in parts[1:]]
+        data={"titulo":a.title,"subtitulo":a.subtitle,"resumen":a.body}
+        if rows: data.update({"headers":headers,"rows":rows})
+        tpl="<h1>{{ titulo }}</h1><p class='muted'>{{ subtitulo }}</p>{% if resumen %}<p>{{ resumen }}</p>{% endif %}{% if tabla is defined and tabla %}{{ tabla }}{% endif %}"
+        try: _print(render_pdf(tpl,a.out,data=data,theme=a.theme)); return 0
+        except Exception as e: print(json.dumps({"status":"error","error":str(e)})); return 1
+    elif a.cmd == "word":
+        try: blocks=json.loads(a.blocks_json or "[]"); _print(create_word(a.out,title=a.title,blocks=blocks,theme=a.theme)); return 0
+        except Exception as e: print(json.dumps({"status":"error","error":str(e)})); return 1
+    elif a.cmd == "excel":
+        try: sheets=json.loads(a.sheets_json or "[]"); _print(create_excel(a.out,title=a.title,sheets=sheets or None,theme=a.theme)); return 0
+        except Exception as e: print(json.dumps({"status":"error","error":str(e)})); return 1
+    return 0
+
+
+if __name__ == "__main__": sys.exit(main())

office_worker_mcp-0.1.0/src/office_worker/core/__init__.py

@@ -0,0 +1,11 @@
+from .themes import load_theme, DEFAULT_THEME, css_vars
+from .templates import render_pdf
+from .word import create_word
+from .excel import create_excel
+from .slides import create_pptx
+from .pdf import read_pdf, extract_tables, list_form_fields
+__all__ = [
+    "load_theme","DEFAULT_THEME","css_vars",
+    "render_pdf","create_word","create_excel","create_pptx",
+    "read_pdf","extract_tables","list_form_fields",
+]

office_worker_mcp-0.1.0/src/office_worker/core/excel.py

@@ -0,0 +1,55 @@
+"""Generación de Excel (.xlsx) con openpyxl, aplicando tema corporativo."""
+from __future__ import annotations
+import os
+from openpyxl import Workbook
+from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+from openpyxl.utils import get_column_letter
+
+def _hex(h):  # "#003366" -> "FF003366" para openpyxl (ARGB)
+    return "FF" + h.lstrip("#").upper()
+
+def create_excel(out_path, title="", sheets=None, theme=None):
+    """Crea un .xlsx profesional.
+
+    sheets: lista de dicts {"name":"Hoja", "headers":[...], "rows":[[...], ...]}
+            Si None → una hoja única "Datos" vacía con título en A1.
+    Devuelve ruta absoluta. Aplica paleta del tema al header y filas alternas.
+    """
+    from .themes import load_theme
+    th = load_theme(theme)
+    primary = _hex(th["primary"]); alt = _hex(th.get("row_alt","#F5F7FA"))
+
+    out_path = os.path.abspath(os.path.expanduser(out_path))
+    os.makedirs(os.path.dirname(out_path), exist_ok=True)
+
+    wb = Workbook(); wb.remove(wb.active)
+    thin = Side(style="thin", color="FFC8D4E0")
+    border = Border(left=thin,right=thin,top=thin,bottom=thin)
+
+    if not sheets:
+        ws = wb.create_sheet("Datos"); ws["A1"]=title or "The Office Worker"; ws["A1"].font=Font(bold=True,color=primary,size=12); wb.save(out_path); return out_path
+
+    for sh in sheets:
+        ws = wb.create_sheet(sh.get("name","Hoja")[:31])
+        headers = sh.get("headers",[]); rows = sh.get("rows",[])
+        start_row = 1
+        if title:
+            ws.cell(1,1,title).font = Font(bold=True,color=primary,size=12)
+        hrow = 2 if title else 1
+        for c,hv in enumerate(headers, start=1):
+            cell = ws.cell(hrow,c,str(hv)); cell.font=Font(bold=True,color="FFFFFFFF")
+            cell.fill=PatternFill("solid",fgColor=primary); cell.alignment=Alignment(horizontal="left"); cell.border=border
+        ridx = hrow+1; i=0
+        for row in rows:
+            for c,cv in enumerate(row,start=1):
+                cell=ws.cell(ridx,c,cv); cell.border=border; cell.alignment=Alignment(vertical="top")
+                if i%2==1: cell.fill=PatternFill("solid",fgColor=alt)
+            ridx+=1; i+=1
+        # auto ancho aprox por contenido (máx 40)
+        for c in range(1,len(headers)+1):
+            maxlen=max([len(str(headers[c-1]))] + [len(str(r[c-1])) for r in rows if c-1<len(r)] or [8])
+            ws.column_dimensions[get_column_letter(c)].width=min(max(maxlen+2,9),40)
+
+    wb.save(out_path)
+    if os.path.getsize(out_path) < 300: raise RuntimeError(f"XLSX sospechosamente pequeño ({os.path.getsize(out_path)}B)")
+    return out_path

office_worker_mcp-0.1.0/src/office_worker/core/pdf.py

@@ -0,0 +1,44 @@
+"""Lectura de PDF (input) — el gap que nadie cubre bien en los MCPs existentes.
+
+Usa PyMuPDF (fitz) para texto/páginas y pdfplumber para tablas. pypdf para metadatos.
+"""
+from __future__ import annotations
+import os
+
+def read_pdf(path, max_pages=None):
+    """Extrae texto por página + metadatos. Devuelve dict {pages:[{n,text}], metadata, n_pages}."""
+    import fitz  # PyMuPDF
+    path = os.path.abspath(os.path.expanduser(path))
+    if not os.path.exists(path): raise FileNotFoundError(path)
+    doc = fitz.open(path)
+    pages = []
+    limit = len(doc) if not max_pages else min(len(doc), int(max_pages))
+    for i in range(limit):
+        pg = doc[i]
+        pages.append({"n": i+1, "text": pg.get_text("text").strip()})
+    meta = doc.metadata or {}
+    out = {"path": path, "n_pages": len(doc), "metadata": {k:meta.get(k) for k in ("title","author","creator","producer") if meta.get(k)}, "pages": pages}
+    doc.close()
+    return out
+
+def extract_tables(path, max_pages=None):
+    """Extrae tablas por página con pdfplumber. Devuelve {page: [tabla(...)]}."""
+    import pdfplumber
+    path = os.path.abspath(os.path.expanduser(path))
+    if not os.path.exists(path): raise FileNotFoundError(path)
+    result = {}
+    with pdfplumber.open(path) as pdf:
+        limit = len(pdf.pages) if not max_pages else min(len(pdf.pages), int(max_pages))
+        for i in range(limit):
+            tbls = pdf.pages[i].extract_tables() or []
+            if tbls: result[i+1] = tbls
+    return {"path": path, "tables_by_page": result, "n_tables": sum(len(v) for v in result.values())}
+
+def list_form_fields(path):
+    """Lista campos de formulario AcroForm (pypdf). Vacío si no es un form."""
+    from pypdf import PdfReader
+    path = os.path.abspath(os.path.expanduser(path))
+    if not os.path.exists(path): raise FileNotFoundError(path)
+    r = PdfReader(path)
+    fields = r.get_fields() or {}
+    return {"path": path, "is_form": bool(fields), "fields": {k:(v.get("/FT"), ) for k,v in fields.items()}}

office_worker_mcp-0.1.0/src/office_worker/core/slides.py

@@ -0,0 +1,67 @@
+"""Generación de PPTX editable vía html-to-pptx (Playwright Chromium).
+
+Cada slide es un <section class="slide">. Inyecta el tema como CSS vars para
+consistencia visual. Produce PPTX NATIVO editable (textos reales, no imágenes).
+Requiere Playwright + Chromium ya instalados (verificado en Fase B).
+"""
+from __future__ import annotations
+import os, tempfile
+
+_SLIDE_CSS = """
+* { box-sizing: border-box; margin: 0; }
+body { font-family: var(--ow-font-body); color: var(--ow-text); }
+.slide { width: 1280px; height: 720px; padding: 56px 64px; background: var(--ow-bg); display:flex; flex-direction:column; }
+.slide h1 { font-family: var(--ow-font-title); font-size: 44px; color: var(--ow-primary); border-bottom: 3px solid var(--ow-primary); padding-bottom: 12px; margin-bottom: 24px; }
+.slide h2 { font-family: var(--ow-font-title); font-size: 30px; color: var(--ow-primary); margin-bottom: 18px; }
+.slide p, .slide li { font-size: 22px; line-height: 1.5; }
+.slide ul { padding-left: 32px; margin-top: 10px; }
+.slide table { width:100%; border-collapse:collapse; font-size:20px; margin-top:16px;}
+.slide th{ background:var(--ow-primary); color:#fff; text-align:left; padding:10px 12px;}
+.slide td{ padding:9px 12px; border-bottom:.5pt solid #c8d4e0;}
+.slide tr:nth-child(even) td{ background:var(--ow-row-alt);}
+.kicker{ color:var(--ow-accent); font-weight:bold; letter-spacing:.5px; text-transform:uppercase; font-size:18px; margin-bottom:8px;}
+"""
+
+def create_pptx(out_path, slides=None, theme=None):
+    """slides: lista de dicts {"title":..., "kicker":..., "bullets":[...]} o {"html":"..."} crudo.
+
+    Si slides es None → una portada genérica. Devuelve ruta absoluta del .pptx editable.
+    """
+    from .themes import load_theme, css_vars
+    th = load_theme(theme)
+
+    parts = []
+    for s in (slides or [{"title": "The Office Worker", "bullets": ["Presentación generada"]}]):
+        if "html" in s and s["html"]:
+            parts.append(f'<section class="slide">{s["html"]}</section>')
+            continue
+        k = f'<div class="kicker">{s.get("kicker","")}</div>' if s.get("kicker") else ""
+        items = "".join(f"<li>{b}</li>" for b in s.get("bullets", []))
+        body = f"<ul>{items}</ul>" if items else f"<p>{s.get('subtitle','')}</p>" if s.get('subtitle') else ""
+        parts.append(
+            f'<section class="slide"><h1>{s.get("title","")}</h1>{k}{body}</section>'
+        )
+
+    deck_html = (f'<!DOCTYPE html><html><head><meta charset="utf-8">'
+                 f'<style>{css_vars(th)}{_SLIDE_CSS}</style></head><body>{"".join(parts)}</body></html>')
+
+    out_path = os.path.abspath(os.path.expanduser(out_path))
+    os.makedirs(os.path.dirname(out_path), exist_ok=True)
+
+    with tempfile.NamedTemporaryFile("w", suffix=".html", delete=False, encoding="utf-8") as tf:
+        tf.write(deck_html); tmp_html = tf.name
+
+    try:
+        import asyncio, concurrent.futures
+        from html_to_pptx import convert
+        # El MCP server corre con su propio event loop; asyncio.run() fallaría ahí.
+        # Ejecutamos convert() en un hilo con su propio loop aislado.
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:
+            result = ex.submit(asyncio.run, convert(tmp_html, out_path)).result(timeout=300)
+    finally:
+        try: os.unlink(tmp_html)
+        except OSError: pass
+
+    if not os.path.exists(result) or os.path.getsize(result) < 3000:
+        raise RuntimeError(f"PPTX generado inválido o vacío ({result})")
+    return result

office_worker_mcp-0.1.0/src/office_worker/core/templates.py

@@ -0,0 +1,69 @@
+"""Núcleo de render: template Jinja + tema → documento.
+
+H1 implementa el camino PDF (HTML/CSS → WeasyPrint), que es el motor de diseño ya
+probado en producción (caso ISO 27001). docx/xlsx/pptx se agregan en hitos siguientes
+reusando la misma entrada (template + data + theme).
+"""
+from __future__ import annotations
+import os
+from jinja2 import Environment, FileSystemLoader, BaseLoader, StrictUndefined
+
+from .themes import load_theme, css_vars
+
+# CSS base compartido por todas las plantillas (usa las variables del tema).
+_BASE_CSS = """
+@page { size: A4; margin: 1.6cm 1.5cm 1.8cm 1.5cm;
+  @bottom-center { content: "Página " counter(page) " de " counter(pages); font-size: 8pt; color: var(--ow-muted); } }
+* { box-sizing: border-box; }
+body { font-family: var(--ow-font-body); font-size: 10pt; line-height: 1.45; color: var(--ow-text); }
+h1 { font-family: var(--ow-font-title); font-size: 17pt; color: var(--ow-primary); border-bottom: 2px solid var(--ow-primary); padding-bottom: 5pt; margin-top: 0; }
+h2 { font-family: var(--ow-font-title); font-size: 12.5pt; color: var(--ow-primary); margin-top: 14pt; }
+p, li { orphans: 3; widows: 3; }
+table { width: 100%; border-collapse: collapse; font-size: 9pt; table-layout: fixed; margin-top: 8pt; }
+th { background: var(--ow-primary); color: #fff; text-align: left; padding: 4pt 6pt; }
+td { padding: 4pt 6pt; border-bottom: .5pt solid #c8d4e0; vertical-align: top; }
+tr:nth-child(even) td { background: var(--ow-row-alt); }
+.muted { color: var(--ow-muted); font-size: 9pt; }
+"""
+
+def _env(template_dir=None):
+    if template_dir and os.path.isdir(template_dir):
+        return Environment(loader=FileSystemLoader(template_dir), undefined=StrictUndefined, autoescape=False)
+    return Environment(loader=BaseLoader(), undefined=StrictUndefined, autoescape=False)
+
+def render_pdf(template_html_or_path, out_path, data=None, theme=None, template_dir=None):
+    """Rellena una plantilla HTML (Jinja) con `data` + `theme` y exporta a PDF vía WeasyPrint.
+
+    - template_html_or_path: string HTML (con placeholders {{ }}) o ruta a un .html.
+    - data: dict de variables para Jinja. Si hay lista 'rows' con 'headers', genera tabla.
+    - theme: dict o nombre/ruta (ver themes.load_theme). None → tema ADEN por defecto.
+    Devuelve la ruta absoluta del PDF generado. Crea out_path si no existe.
+    """
+    from weasyprint import HTML
+
+    th = load_theme(theme)
+
+    # ¿es ruta a archivo o HTML inline?
+    if template_html_or_path and os.path.exists(str(template_html_or_path)):
+        tpl_text = open(template_html_or_path).read()
+    else:
+        tpl_text = str(template_html_or_path or "")
+
+    env = _env(template_dir)
+    tmpl = env.from_string(tpl_text)
+
+    # helper opcional para tablas declarativas en la plantilla via contexto simple
+    ctx = dict(data or {})
+
+    body = tmpl.render(**ctx)
+
+    html_doc = f"""<!DOCTYPE html><html lang="es"><head><meta charset="utf-8">
+<style>{css_vars(th)}{_BASE_CSS}</style></head><body>{body}</body></html>"""
+
+    out_path = os.path.abspath(os.path.expanduser(out_path))
+    os.makedirs(os.path.dirname(out_path), exist_ok=True)
+    HTML(string=html_doc).write_pdf(out_path)
+
+    if os.path.getsize(out_path) < 500:
+        raise RuntimeError(f"PDF generado sospechosamente pequeño ({os.path.getsize(out_path)}B): revisar plantilla/datos")
+    return out_path

office_worker_mcp-0.1.0/src/office_worker/core/themes.py

@@ -0,0 +1,49 @@
+"""Capa de temas corporativos.
+
+Un tema es un dict con paleta + tipografía que se inyecta como CSS variables en las
+plantillas HTML (para PDF vía WeasyPrint) y como constantes para docx/xlsx/pptx.
+Esto resuelve el gap #3 de office-mcp: diseño consistente aplicable de una vez,
+en vez de parámetros sueltos por llamada.
+"""
+from __future__ import annotations
+import os
+
+# Tema por defecto (paleta ADEN usada ya en producción).
+DEFAULT_THEME = {
+    "name": "aden",
+    "primary": "#003366",      # azul oscuro — encabezados, headers de tabla
+    "accent": "#3B82F6",       # acento — cabeceras destacadas, enlaces
+    "text": "#1A202C",         # cuerpo
+    "muted": "#718096",        # secundario / pies
+    "row_alt": "#F5F7FA",      # filas alternas de tabla
+    "bg": "#FFFFFF",           # fondo
+    "font_title": "Helvetica Neue, Arial, sans-serif",
+    "font_body": "Helvetica Neue, Arial, sans-serif",
+}
+
+def load_theme(name_or_path: str | None) -> dict:
+    """Devuelve un tema por nombre conocido o ruta a YAML/JSON. Sin arg → DEFAULT_THEME."""
+    if not name_or_path:
+        return dict(DEFAULT_THEME)
+    p = name_or_path
+    if os.path.exists(p):
+        text = open(p).read()
+        if p.endswith((".yaml", ".yml")):
+            import yaml  # opcional; solo si cargan tema desde archivo YAML
+            data = yaml.safe_load(text) or {}
+        else:
+            import json as _json
+            data = _json.loads(text) or {}
+        base = dict(DEFAULT_THEME); base.update(data); base.setdefault("name", os.path.basename(p))
+        return base
+    # nombre conocido (extender después con más temas empaquetados)
+    return dict(DEFAULT_THEME)
+
+def css_vars(theme: dict) -> str:
+    """Bloque :root con las variables CSS del tema, listo para inyectar en <style>."""
+    return (
+        f":root{{ --ow-primary:{theme['primary']}; --ow-accent:{theme['accent']};"
+        f"--ow-text:{theme['text']}; --ow-muted:{theme['muted']};"
+        f"--ow-row-alt:{theme['row_alt']}; --ow-bg:{theme['bg']};"
+        f"--ow-font-title:{theme['font_title']}; --ow-font-body:{theme['font_body']}; }}"
+    )

office_worker_mcp-0.1.0/src/office_worker/core/word.py

@@ -0,0 +1,60 @@
+"""Generación de Word (.docx) con python-docx, aplicando tema corporativo."""
+from __future__ import annotations
+import os
+from docx import Document
+from docx.shared import Pt, RGBColor, Inches
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+def _hex_to_rgb(h):
+    h = h.lstrip("#")
+    return RGBColor(int(h[0:2],16), int(h[2:4],16), int(h[4:6],16))
+
+def create_word(out_path, title="", subtitle=None, blocks=None, theme=None):
+    """Crea un .docx profesional.
+
+    blocks: lista de dicts. Tipos soportados:
+      {"type":"h1"|"h2"|"p", "text": "..."}
+      {"type":"table", "headers":[...], "rows":[[...], ...]}
+    Si blocks es None → documento mínimo con título. Devuelve ruta absoluta.
+    """
+    from .themes import load_theme
+    th = load_theme(theme)
+    primary = _hex_to_rgb(th["primary"])
+
+    out_path = os.path.abspath(os.path.expanduser(out_path))
+    os.makedirs(os.path.dirname(out_path), exist_ok=True)
+
+    doc = Document()
+    # estilo base de fuente/cuerpo según tema
+    st = doc.styles["Normal"]; st.font.name = th.get("font_body","Arial"); st.font.size = Pt(10.5)
+
+    if title:
+        h = doc.add_heading(title, level=0); 
+        for r in h.runs: r.font.color.rgb = primary
+    if subtitle:
+        p = doc.add_paragraph(subtitle)
+        if p.runs: p.runs[0].font.color.rgb = _hex_to_rgb(th["muted"])
+
+    for b in (blocks or []):
+        t = b.get("type","p")
+        if t == "h1":
+            hh = doc.add_heading(b["text"], level=1)
+            for r in hh.runs: r.font.color.rgb = primary
+        elif t == "h2":
+            hh = doc.add_heading(b["text"], level=2)
+            for r in hh.runs: r.font.color.rgb = primary
+        elif t == "table":
+            headers = b.get("headers",[]); rows = b.get("rows",[])
+            tbl = doc.add_table(rows=1, cols=len(headers)); tbl.style="Light Grid Accent 1"
+            hdr = tbl.rows[0].cells
+            for i,hv in enumerate(headers): hdr[i].text=str(hv)
+            for row in rows:
+                cells = tbl.add_row().cells
+                for i,cv in enumerate(row):
+                    if i < len(cells): cells[i].text=str(cv)
+        else:  # p / default
+            doc.add_paragraph(b.get("text",""))
+
+    doc.save(out_path)
+    if os.path.getsize(out_path) < 300: raise RuntimeError(f"DOCX sospechosamente pequeño ({os.path.getsize(out_path)}B)")
+    return out_path

office_worker_mcp-0.1.0/src/office_worker/mcp_server.py

@@ -0,0 +1,100 @@
+"""The Office Worker — MCP server (cara delgada sobre office_worker.core).
+
+Meta: pocas tools poderosas (~8 aquí), no 47 CRUD genéricas → bajo overhead de contexto.
+Cada tool crea/lee un archivo real y devuelve {status, path, ...} o {status:"error", error}.
+Regla anti-loop en instructions: si una tool falla 2 veces, NO reintentar con variantes.
+"""
+from __future__ import annotations
+import os, json
+
+from mcp.server.fastmcp import FastMCP
+
+from office_worker.core import (
+    render_pdf as _render_pdf,
+    create_word as _create_word,
+    create_excel as _create_excel,
+    create_pptx as _create_pptx,
+    read_pdf as _read_pdf,
+    extract_tables as _extract_tables,
+    list_form_fields as _list_form_fields,
+    load_theme, DEFAULT_THEME,
+)
+
+mcp = FastMCP(
+    "office-worker",
+    instructions=(
+        "The Office Worker: genera documentos de oficina profesionales (PDF/Word/Excel/PPTX) "
+        "desde datos + tema corporativo, y lee PDFs (texto/tablas/formularios). "
+        "Usa la tool que corresponda al formato pedido. Regla anti-loop: si una llamada falla 2 "
+        "veces, NO reintentes con variantes; reporta el error exacto y detente."
+    ),
+)
+
+
+def _ok(path): return {"status": "ok", "path": os.path.abspath(path), "bytes": os.path.getsize(path)}
+
+@mcp.tool()
+def render_document(template_html: str, out_path: str, data_json: str = "{}", theme: str | None = None) -> dict:
+    """Genera un PDF profesional desde plantilla HTML/Jinja + datos + tema."""
+    try: data = json.loads(data_json or "{}") or {}
+    except json.JSONDecodeError as e: return {"status":"error","error":f"data_json inválido: {e}"}
+    if isinstance(data.get("rows"), list):
+        headers=data.get("headers") or []
+        thead="".join(f"<th>{h}</th>" for h in headers)
+        body="\n".join("<tr>"+"".join(f"<td>{c}</td>" for c in r)+"</tr>" for r in data["rows"])
+        data["tabla"]=f"<table><thead><tr>{thead}</tr></thead><tbody>{body}</tbody></table>"
+    try: return _ok(_render_pdf(template_html, out_path, data=data, theme=theme))
+    except Exception as e: return {"status":"error","error":str(e)}
+
+@mcp.tool()
+def create_word(out_path: str, title: str = "", subtitle: str | None = None, blocks_json: str = "[]", theme: str | None = None) -> dict:
+    """Crea un .docx. blocks_json: JSON lista de {"type":"h1|h2|p|table","text"|"headers"/"rows"}."""
+    try: blocks=json.loads(blocks_json or "[]") or []
+    except json.JSONDecodeError as e: return {"status":"error","error":f"blocks_json inválido: {e}"}
+    try: return _ok(_create_word(out_path,title=title,subtitle=subtitle,blocks=blocks,theme=theme))
+    except Exception as e: return {"status":"error","error":str(e)}
+
+@mcp.tool()
+def create_excel(out_path: str, title: str = "", sheets_json: str = "[]", theme: str | None = None) -> dict:
+    """Crea un .xlsx. sheets_json: JSON lista de {"name","headers":[...],"rows":[[...]]}."""
+    try: sheets=json.loads(sheets_json or "[]") or []
+    except json.JSONDecodeError as e: return {"status":"error","error":f"sheets_json inválido: {e}"}
+    try: return _ok(_create_excel(out_path,title=title,sheets=sheets or None,theme=theme))
+    except Exception as e: return {"status":"error","error":str(e)}
+
+@mcp.tool()
+def create_pptx(out_path: str, slides_json: str = "[]", theme: str | None = None) -> dict:
+    """Crea un .pptx EDITABLE. slides_json: JSON lista de {"title","kicker","bullets":[...]}."""
+    try: slides=json.loads(slides_json or "[]") or []
+    except json.JSONDecodeError as e: return {"status":"error","error":f"slides_json inválido: {e}"}
+    try: return _ok(_create_pptx(out_path,slides=slides or None,theme=theme))
+    except Exception as e: return {"status":"error","error":str(e)}
+
+@mcp.tool()
+def read_pdf(path: str, max_pages: int | None = None) -> dict:
+    """Lee texto + metadatos de un PDF (input). Devuelve páginas con su texto."""
+    try: return _read_pdf(path,max_pages=max_pages) | {"status":"ok"}
+    except Exception as e: return {"status":"error","error":str(e)}
+
+@mcp.tool()
+def pdf_extract_tables(path: str, max_pages: int | None = None) -> dict:
+    """Extrae tablas estructuradas de un PDF (pdfplumber)."""
+    try: return _extract_tables(path,max_pages=max_pages) | {"status":"ok"}
+    except Exception as e: return {"status":"error","error":str(e)}
+
+@mcp.tool()
+def pdf_list_form_fields(path: str) -> dict:
+    """Lista campos de formulario AcroForm de un PDF (vacío si no es form)."""
+    try: return _list_form_fields(path) | {"status":"ok"}
+    except Exception as e: return {"status":"error","error":str(e)}
+
+@mcp.tool()
+def list_themes(theme_name_or_path: str | None = None) -> dict:
+    """Devuelve el tema resuelto (paleta+fuente) para usarlo como referencia de diseño."""
+    t = load_theme(theme_name_or_path) if theme_name_or_path else dict(DEFAULT_THEME)
+    return {"status":"ok","theme":t}
+
+
+def main(): mcp.run()
+
+if __name__ == "__main__": main()

office_worker_mcp-0.1.0/src/office_worker_mcp.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: office-worker-mcp
+Version: 0.1.0
+Summary: The Office Worker — your agent's document clerk: Word, Excel, PowerPoint & PDF with real design (templates + themes + PDF input).
+Author: Julio Cardozo
+License: MIT
+Keywords: mcp,office,pdf,docx,xlsx,pptx,documents,agent,templates
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: mcp[cli]<2,>=1.27
+Requires-Dist: python-docx>=1.0
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: python-pptx>=1.0
+Requires-Dist: weasyprint>=60
+Requires-Dist: jinja2>=3.1
+Requires-Dist: PyMuPDF>=1.24
+Requires-Dist: pdfplumber>=0.11
+Requires-Dist: pypdf>=4
+Provides-Extra: pptx
+Requires-Dist: html-to-pptx>=0.3; extra == "pptx"
+Requires-Dist: playwright>=1.40; extra == "pptx"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: html-to-pptx>=0.3; extra == "dev"
+Requires-Dist: playwright>=1.40; extra == "dev"
+Dynamic: license-file
+
+# The Office Worker — `office-worker-mcp`
+
+> **Your agent's document clerk.** Genera documentos de oficina profesionales —
+> **PDF, Word, Excel y PowerPoint** — desde datos + un tema corporativo, y lee PDFs
+> (texto, tablas y formularios). Diseñado para agentes de IA (Hermes, Claude, Cursor)
+> vía [MCP](https://modelcontextprotocol.io), 100% local-first.
+
+```
+pip install office-worker-mcp          # instala librería + MCP server + CLI 'owi'
+```
+
+Conectalo a tu agente (ejemplo config MCP / stdio):
+
+```json
+{ "mcpServers": { "office-worker": { "command": "office-worker-mcp" } } }
+```
+
+Y listo: le pedís *"haceme una factura/informe/deck"* en lenguaje natural y tu agente
+usa las tools del oficinista para producir el archivo bien diseñado.
+
+## Por qué existe (diferenciadores)
+
+Los MCPs de documentos existentes son CRUD genéricos (47+ tools que inflan el contexto)
+y no cubren diseño ni PDF como entrada. El Office Worker hace lo contrario:
+
+| | office-mcp / takos | **The Office Worker** |
+|---|---|---|
+| Tools | ~47–80 CRUD genéricas | **8 poderosas** (~2K tok/turno vs ~6.4K) |
+| Plantillas con variables | ❌ | ✅ Jinja (`{{ var }}`) |
+| Temas corporativos (paleta/fuente) | ❌ parámetros sueltos | ✅ aplicable de una vez a todos los formatos |
+| PDF como **input** (leer/tablas/formularios) | ❌ | ✅ PyMuPDF + pdfplumber + pypdf |
+| PPTX **editable** (textos nativos, no imágenes) | parcial | ✅ html-to-pptx verificado |
+| Guía anti-loop para agentes | ❌ | ✅ SKILL.md con reglas probadas en producción |
+
+## Las 8 tools
+
+| Tool | Qué hace |
+|---|---|
+| `render_document` | PDF profesional desde plantilla HTML/Jinja + datos + tema (WeasyPrint) |
+| `create_word` | `.docx` con h1/h2/párrafos/tablas, tema aplicado (python-docx) |
+| `create_excel` | `.xlsx` multi-hoja con paleta y filas alternas (openpyxl) |
+| `create_pptx` | `.pptx` **editable** desde slides declarativas (html-to-pptx + Playwright) |
+| `read_pdf` | Extrae texto por página + metadatos de un PDF (input) |
+| `pdf_extract_tables` | Tablas estructuradas de un PDF (pdfplumber) |
+| `pdf_list_form_fields` | Campos de formulario AcroForm de un PDF (pypdf) |
+| `list_themes` | Devuelve la paleta/fuente del tema activo como referencia de diseño |
+
+## Uso rápido (sin agente, vía CLI o Python)
+
+```python
+from office_worker.core import create_word, create_excel, render_pdf
+
+create_word("acta.docx", title="Acta", subtitle="Reunión", blocks=[
+    {"type":"h2","text":"Puntos"}, {"type":"p","text":"Decisión tomada"}])
+
+create_excel("balance.xlsx", title="Balance", sheets=[{"name":"Resumen",
+    "headers":["Rubro","Monto"],"rows":[["Ingresos",100],["Gastos",40]]}])
+```
+
+## Requisitos locales
+
+- Python ≥ 3.9 · WeasyPrint (necesita fontconfig/pango en Linux) · LibreOffice opcional.
+- **PPTX editable** (opcional): `pip install office-worker-mcp[pptx]` + `playwright install chromium`.
+  Sin este extra, las tools de PDF/Word/Excel funcionan igual; solo `create_pptx` queda deshabilitada.
+- Todo corre en local; sin cloud.
+
+## Desarrollo & tests
+
+```bash
+pip install -e ".[dev]"
+pytest            # test_core.py (núcleo) + test_e2e_mcp.py (MCP end-to-end, 8/8 tools)
+```
+
+El test E2E levanta el servidor MCP real, hace handshake y ejecuta cada tool creando/leyendo archivos válidos en disco.
+
+## Licencia
+
+MIT — ver [LICENSE](LICENSE). Agradecimientos en [NOTICE](NOTICE).

office_worker_mcp-0.1.0/src/office_worker_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+NOTICE
+README.md
+pyproject.toml
+src/office_worker/__init__.py
+src/office_worker/cli.py
+src/office_worker/mcp_server.py
+src/office_worker/core/__init__.py
+src/office_worker/core/excel.py
+src/office_worker/core/pdf.py
+src/office_worker/core/slides.py
+src/office_worker/core/templates.py
+src/office_worker/core/themes.py
+src/office_worker/core/word.py
+src/office_worker_mcp.egg-info/PKG-INFO
+src/office_worker_mcp.egg-info/SOURCES.txt
+src/office_worker_mcp.egg-info/dependency_links.txt
+src/office_worker_mcp.egg-info/entry_points.txt
+src/office_worker_mcp.egg-info/requires.txt
+src/office_worker_mcp.egg-info/top_level.txt
+tests/test_core.py
+tests/test_e2e_mcp.py

office_worker_mcp-0.1.0/src/office_worker_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

office_worker_mcp-0.1.0/src/office_worker_mcp.egg-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+office-worker-mcp = office_worker.mcp_server:main
+owi = office_worker.cli:main
+
+[mcp.servers]
+office_worker = office_worker.mcp_server:main

office_worker_mcp-0.1.0/src/office_worker_mcp.egg-info/requires.txt

@@ -0,0 +1,19 @@
+mcp[cli]<2,>=1.27
+python-docx>=1.0
+openpyxl>=3.1
+python-pptx>=1.0
+weasyprint>=60
+jinja2>=3.1
+PyMuPDF>=1.24
+pdfplumber>=0.11
+pypdf>=4
+
+[dev]
+pytest>=8
+pytest-asyncio>=0.23
+html-to-pptx>=0.3
+playwright>=1.40
+
+[pptx]
+html-to-pptx>=0.3
+playwright>=1.40

office_worker_mcp-0.1.0/src/office_worker_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+office_worker

office_worker_mcp-0.1.0/tests/test_core.py

@@ -0,0 +1,36 @@
+"""Test del núcleo: render_document → PDF real. (H1)"""
+import os, sys, tempfile
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from office_worker.core.templates import render_pdf
+
+TPL = """<h1>{{ titulo }}</h1><p class="muted">{{ subtitulo }} · {{ fecha }}</p>
+{% if tabla is defined and tabla %}{{ tabla }}{% endif %}"""
+
+def test_render_pdf(tmp_path):
+    out = str(tmp_path / "out.pdf")
+    data = {
+        "titulo": "Informe de Prueba",
+        "subtitulo": "The Office Worker H1",
+        "fecha": "2026-09-05",
+        "headers": ["Rubro", "Valor"],
+        "rows": [["Ingresos", "$1.200.000"], ["Gastos", "$800.000"]],
+    }
+    # emular el helper de tabla que hace el MCP server antes de llamar al núcleo
+    headers = data["headers"]; rows = data["rows"]
+    thead = "".join(f"<th>{h}</th>" for h in headers)
+    body = "\n".join("<tr>" + "".join(f"<td>{c}</td>" for c in r) + "</tr>" for r in rows)
+    data["tabla"] = f"<table><thead><tr>{thead}</tr></thead><tbody>{body}</tbody></table>"
+
+    path = render_pdf(TPL, out, data=data)  # tema por defecto ADEN
+    assert os.path.exists(path), "PDF no creado"
+    size = os.path.getsize(path)
+    assert size > 500, f"PDF demasiado chico: {size}"
+    head = open(path, "rb").read(5)
+    assert head == b"%PDF-", f"No es PDF válido: {head!r}"
+    print(f"OK — PDF generado: {path} ({size} bytes)")
+
+if __name__ == "__main__":
+    import pathlib, tempfile
+    with tempfile.TemporaryDirectory() as d:
+        test_render_pdf(pathlib.Path(d))

office_worker_mcp-0.1.0/tests/test_e2e_mcp.py

@@ -0,0 +1,72 @@
+"""Test E2E del MCP completo como test de pytest (async).
+
+Levanta el servidor MCP real, hace handshake y ejecuta cada tool creando/leyendo
+archivos válidos en disco. PPTX se saltea si Playwright no está disponible.
+Requiere: pytest-asyncio (en extras [dev]).
+"""
+import asyncio, json, os, sys, pathlib
+import pytest
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent.parent / "src"))
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+
+@pytest.mark.asyncio
+async def test_office_worker_mcp_e2e(tmp_path):
+    d = str(tmp_path)
+    env = {**os.environ, "PYTHONPATH": str(pathlib.Path(__file__).parent.parent / "src")}
+    params = StdioServerParameters(command=sys.executable, args=["-m", "office_worker.mcp_server"], env=env)
+
+    results = {}
+    async with stdio_client(params) as (r, w):
+        async with ClientSession(r, w) as s:
+            await s.initialize()
+            tools = [t.name for t in (await s.list_tools()).tools]
+            assert len(tools) == 8 and "render_document" in tools, f"tools inesperadas: {tools}"
+
+            async def call(name, args): return json.loads((await s.call_tool(name, args)).content[0].text)
+
+            # 1 PDF con tabla declarativa
+            r = await call("render_document", {
+                "template_html": "<h1>{{ titulo }}</h1><p class='muted'>{{ subtitulo }}</p>{% if tabla is defined and tabla %}{{ tabla }}{% endif %}",
+                "out_path": f"{d}/a.pdf",
+                "data_json": json.dumps({"titulo": "Informe", "subtitulo": "E2E", "headers": ["KPI", "V"], "rows": [["A", 1], ["B", 2]]})})
+            results["pdf"] = r; assert r["status"] == "ok" and os.path.exists(r["path"]), r
+
+            # 2 Word
+            r = await call("create_word", {
+                "out_path": f"{d}/b.docx", "title": "Acta", "subtitle": "Reunión",
+                "blocks_json": json.dumps([{"type": "h2", "text": "Puntos"}, {"type": "p", "text": "Decisión"}, {"type": "table", "headers": ["Item", "Estado"], "rows": [["X", "OK"]]}])})
+            results["docx"] = r; assert r["status"] == "ok" and os.path.exists(r["path"]), r
+
+            # 3 Excel multi-hoja
+            r = await call("create_excel", {
+                "out_path": f"{d}/c.xlsx", "title": "Balance",
+                "sheets_json": json.dumps([{"name": "Resumen", "headers": ["Rubro", "Monto"], "rows": [["Ingresos", 100], ["Gastos", 40]]}])})
+            results["xlsx"] = r; assert r["status"] == "ok" and os.path.exists(r["path"]), r
+
+            # 4 PPTX editable — se saltea si no hay Playwright instalado en el entorno
+            try:
+                import playwright  # noqa: F401
+                have_pw = True
+            except Exception:
+                have_pw = False
+            if have_pw:
+                r = await call("create_pptx", {
+                    "out_path": f"{d}/d.pptx",
+                    "slides_json": json.dumps([{"title": "Portada", "kicker": "The Office Worker"}, {"title": "Agenda", "bullets": ["Intro", "Resultados"]}])})
+                results["pptx"] = r; assert r["status"] == "ok" and os.path.exists(r["path"]), r
+            else:
+                results["pptx"] = {"status": "skipped"}
+
+            # 5-7 PDF input sobre el PDF generado en (1)
+            r = await call("read_pdf", {"path": results["pdf"]["path"]}); results["read_pdf"] = r; assert r.get("n_pages", 0) >= 1 and r.get("pages"), r
+            r = await call("pdf_extract_tables", {"path": results["pdf"]["path"]}); results["tables"] = r; assert r.get("status") == "ok", r
+            r = await call("pdf_list_form_fields", {"path": results["pdf"]["path"]}); results["forms"] = r; assert r.get("status") == "ok", r
+
+            # 8 temas
+            r = await call("list_themes", {}); results["themes"] = r; assert r.get("theme", {}).get("primary"), r
+
+    # El PDF ya se validó arriba vía read_pdf (n_pages>=1 + texto real extraído).