@heylemon/lemonade 0.1.8 → 0.1.9

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.8",
-  "commit": "afe9f4d0fa565323c39787bae2854ba5905b5a21",
-  "builtAt": "2026-02-21T18:20:37.765Z"
+  "version": "0.1.9",
+  "commit": "148a3ecd94824b7bed57702ff16e416442b7d831",
+  "builtAt": "2026-02-21T19:41:57.574Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-38125fabd1c2129cedf329e3c20fd69940046e0859a30f6906f3ff0f944a5aaa
+b3ce500e7c71ed0a3415b4d2d8e472926cb0135cdb8a2f66ab05abb127c334ac

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heylemon/lemonade",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "AI gateway CLI for Lemon - local AI assistant with integrations",
   "publishConfig": {
     "access": "restricted"

package/skills/docx/SKILL.md

@@ -7,14 +7,30 @@ description: "Create professional, polished documents — reports, memos, propos
 
 Create polished, production-ready documents using docx-js, the clean standards-compliant Node.js library for producing .docx files. This skill writes bespoke code for each request rather than using JSON templates — you have full control over the document API.
 
+## ⚠️ MANDATORY: Post-Processing After Every Build
+
+docx-js has TWO bugs that cause documents to look wrong in Apple Pages and Google Docs. **After generating ANY document, you MUST run BOTH scripts:**
+
+```bash
+# Step 1: Fix table column grids (tables break in Pages without this)
+python scripts/fix_tables.py output.docx
+
+# Step 2: Fix heading styles (headings show wrong colors/fonts in Pages without this)
+python scripts/fix_styles.py output.docx
+```
+
+These are not optional. Without fix_tables.py, tables render as 1-character-wide columns in Pages. Without fix_styles.py, headings appear in default blue instead of your custom colors. Run both immediately after `node create-doc.js`, before delivering the file. The scripts are located in the same skill folder as this SKILL.md.
+
 ## Quick Reference
 
 | Task | Approach | Tool |
 |------|----------|------|
-| **Create new document** | Write docx-js code using Document, Packer, Paragraph, TextRun, Table | Node.js + docx-js |
+| **Create new document** | Write docx-js code, then run both fix scripts | Node.js + docx-js |
 | **Read/analyze existing** | Unzip → read document.xml or use pandoc for content extraction | unzip or pandoc |
 | **Edit existing file** | Unzip → modify XML → repack into .docx | unzip + JSZip |
 | **Validate output** | Check XML, fonts, structure, paragraphs | `python scripts/validate.py` |
+| **Fix tables (MANDATORY)** | Patch tblGrid for cross-platform | `python scripts/fix_tables.py output.docx` |
+| **Fix styles (MANDATORY)** | Patch heading styles for cross-platform | `python scripts/fix_styles.py output.docx` |
 | **Visual QA** | Convert to PDF then to images | soffice + pdftoppm |
 
 ---
@@ -102,33 +118,37 @@ const COLORS = {
 
 ### Creating Headings with Styles
 
-Override built-in heading styles to ensure they appear in TOC. Use `outlineLevel` to control Table of Contents depth:
+**CRITICAL: Use `children` with TextRun, NOT the `run` property.** The `run` property puts formatting in `pPr/rPr` (paragraph default run properties) but the actual `<w:r>` gets no `<w:rPr>`. Word inherits from `pPr/rPr` just fine, but Apple Pages reads from `styles.xml` instead and ignores inline paragraph-level overrides. By using `children` with an explicit `TextRun`, the formatting goes directly on the run itself, which Pages always respects.
 
 ```javascript
+// ✅ CORRECT — formatting on the TextRun (works in Pages)
 new Paragraph({
-  text: "Section Title",
   heading: HeadingLevel.HEADING_1,
-  outlineLevel: 0,  // Appears in TOC
-  style: "Heading1",
-  run: {
-    bold: true,
-    size: TYPOGRAPHY.h1,
-    color: COLORS.primary,
-    font: "Arial"
-  },
-  spacing: { before: 480, after: 160 }  // 12pt before, 4pt after
+  spacing: { before: 480, after: 160 },
+  children: [
+    new TextRun({
+      text: "Section Title",
+      bold: true,
+      size: TYPOGRAPHY.h1,
+      color: COLORS.primary,
+      font: "Arial"
+    })
+  ]
 });
 
+// ❌ WRONG — formatting on `run` property (breaks in Pages)
 new Paragraph({
   text: "Subsection",
-  heading: HeadingLevel.HEADING_2,
-  outlineLevel: 1,
-  style: "Heading2",
-  run: { size: TYPOGRAPHY.h2, color: COLORS.primary },
-  spacing: { before: 360, after: 120 }
+  heading: HeadingLevel.HEADING_1,
+  style: "Heading1",
+  run: { bold: true, size: TYPOGRAPHY.h1, color: COLORS.primary, font: "Arial" },
+  spacing: { before: 480, after: 160 }
 });
 ```
 
+Also note: use `italics: true` (with 's'), not `italic: true`. The latter silently does nothing in docx-js.
+```
+
 ### Lists: Never Use Unicode Bullets
 
 CRITICAL: Never manually insert bullet characters like •, ◦, ▪. Use the list APIs:
@@ -324,7 +344,8 @@ Or use a more sophisticated approach with field codes (requires XML manipulation
 - Set both table width AND individual cell widths in DXA
 - Use `ShadingType.CLEAR` for cell backgrounds
 - Use `HeadingLevel.HEADING_1`, etc., with `outlineLevel` for TOC
-- Override heading styles with explicit `style: "Heading1"` properties
+- Use `children` with TextRun for headings, NOT the `run` property (Pages ignores `run`)
+- Use `italics: true` (with 's'), not `italic: true`
 - Set `spacing.before` and `spacing.after` explicitly on headings
 
 **DON'T:**
@@ -336,6 +357,8 @@ Or use a more sophisticated approach with field codes (requires XML manipulation
 - Forget cell width specifications (columns collapse)
 - Use `ShadingType.SOLID` (use CLEAR)
 - Assume A4 page size (always set explicitly to US Letter)
+- Use `run` property on headings (use `children` with TextRun instead — Pages ignores `run`)
+- Use `italic: true` without the 's' (use `italics: true`)
 - Mix font styles — stick to 2 fonts (heading + body)
 
 ---
@@ -444,7 +467,23 @@ This script:
 
 **Always run this after generating any document with tables.** Without it, tables will look correct in Word but break in Pages and Google Docs.
 
-### 3. Visual Check (PDF Conversion)
+### 3. Fix Heading Styles for Cross-Platform (MANDATORY)
+
+docx-js generates default blue heading styles in `styles.xml` regardless of your inline formatting. Word uses inline run properties, but Pages reads `styles.xml` first, causing headings to appear in the wrong color/font/size.
+
+```bash
+python scripts/fix_styles.py report.docx
+```
+
+This script:
+- Reads each heading's actual inline formatting (color, font, size, bold) from the document
+- Patches `styles.xml` heading style definitions to match
+- Adds paragraph spacing to style definitions
+- Overwrites the file in place (or pass a second arg for a new file)
+
+**Always run this after generating any document with headings.** Without it, headings will look correct in Word but show default blue colors in Pages.
+
+### 4. Visual Check (PDF Conversion)
 
 ```bash
 # Convert to PDF
@@ -456,14 +495,15 @@ pdftoppm -jpeg -r 150 report.pdf page
 # View: page-1.jpg, page-2.jpg, etc.
 ```
 
-### 4. Fix & Re-validate
+### 5. Fix & Re-validate
 
 If the validator reports issues or the PDF looks off:
 1. Fix the docx-js code
 2. Re-run to regenerate .docx
 3. Run `fix_tables.py` again (step 2)
-4. Re-validate with `validate.py`
-5. Re-convert to PDF if visual issues
+4. Run `fix_styles.py` again (step 3)
+5. Re-validate with `validate.py`
+6. Re-convert to PDF if visual issues
 
 Iterate until both validation passes and visual output looks polished.
 

package/skills/docx/scripts/fix_styles.py

@@ -0,0 +1,394 @@
+#!/usr/bin/env python3
+"""
+fix_styles.py — Patch styles.xml in a .docx for Apple Pages compatibility.
+
+docx-js generates styles.xml with THREE problems that break Pages rendering:
+
+1. Empty docDefaults — <w:rPrDefault/> and <w:pPrDefault/> with no content.
+   Pages needs proper defaults (font, size, language, paragraph spacing) to
+   correctly interpret inline paragraph properties like w:jc (alignment).
+
+2. Missing Normal style — No default paragraph style is defined. Pages needs
+   a Normal style with w:default="1" as the base for all paragraph rendering.
+   Without it, Pages ignores inline paragraph formatting like center alignment.
+
+3. Wrong heading colors — Heading styles have default blue (#2E74B5) colors
+   regardless of what colors you use in the document. Pages reads styles.xml
+   instead of inline run properties.
+
+This script fixes all three issues by:
+- Adding proper docDefaults with font, size, language, and paragraph spacing
+- Adding a Normal style with w:default="1" if it doesn't exist
+- Reading actual heading formatting from the document and patching styles.xml
+
+Usage:
+    python fix_styles.py input.docx [output.docx]
+
+If output is omitted, the file is modified in place.
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+import zipfile
+from xml.etree import ElementTree as ET
+
+NS = {
+    "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    "mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+    "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+}
+
+# Register all namespaces to preserve them on write
+for prefix, uri in NS.items():
+    ET.register_namespace(prefix, uri)
+
+# Register additional namespaces commonly in docx
+EXTRA_NS = {
+    "wpc": "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
+    "o": "urn:schemas-microsoft-com:office:office",
+    "m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
+    "v": "urn:schemas-microsoft-com:vml",
+    "wp14": "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+    "wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+    "w10": "urn:schemas-microsoft-com:office:word",
+    "w14": "http://schemas.microsoft.com/office/word/2010/wordml",
+    "w15": "http://schemas.microsoft.com/office/word/2012/wordml",
+    "wpg": "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+    "wpi": "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
+    "wne": "http://schemas.microsoft.com/office/word/2006/wordml",
+    "wps": "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
+}
+for prefix, uri in EXTRA_NS.items():
+    ET.register_namespace(prefix, uri)
+
+W = NS["w"]
+WNS = f"{{{W}}}"
+
+
+def fix_doc_defaults(root):
+    """
+    Ensure docDefaults has proper rPrDefault and pPrDefault.
+    Pages needs these to correctly resolve inline paragraph properties.
+    """
+    doc_defaults = root.find(f"{WNS}docDefaults")
+    if doc_defaults is None:
+        # Insert docDefaults as first child
+        doc_defaults = ET.SubElement(root, f"{WNS}docDefaults")
+        root.insert(0, doc_defaults)
+
+    fixed = False
+
+    # Fix rPrDefault
+    rpr_default = doc_defaults.find(f"{WNS}rPrDefault")
+    if rpr_default is None:
+        rpr_default = ET.SubElement(doc_defaults, f"{WNS}rPrDefault")
+
+    rpr = rpr_default.find(f"{WNS}rPr")
+    if rpr is None or len(rpr) == 0:
+        # Empty rPrDefault — add proper defaults
+        if rpr is not None:
+            doc_defaults.remove(rpr_default)
+            rpr_default = ET.SubElement(doc_defaults, f"{WNS}rPrDefault")
+
+        rpr = ET.SubElement(rpr_default, f"{WNS}rPr")
+
+        # Default fonts
+        fonts = ET.SubElement(rpr, f"{WNS}rFonts")
+        fonts.set(f"{WNS}asciiTheme", "minorHAnsi")
+        fonts.set(f"{WNS}eastAsiaTheme", "minorEastAsia")
+        fonts.set(f"{WNS}hAnsiTheme", "minorHAnsi")
+        fonts.set(f"{WNS}cstheme", "minorBidi")
+
+        # Default size (11pt = 22 half-points)
+        sz = ET.SubElement(rpr, f"{WNS}sz")
+        sz.set(f"{WNS}val", "22")
+        sz_cs = ET.SubElement(rpr, f"{WNS}szCs")
+        sz_cs.set(f"{WNS}val", "22")
+
+        # Language
+        lang = ET.SubElement(rpr, f"{WNS}lang")
+        lang.set(f"{WNS}val", "en-US")
+        lang.set(f"{WNS}eastAsia", "en-US")
+        lang.set(f"{WNS}bidi", "ar-SA")
+
+        fixed = True
+
+    # Fix pPrDefault
+    ppr_default = doc_defaults.find(f"{WNS}pPrDefault")
+    if ppr_default is None:
+        ppr_default = ET.SubElement(doc_defaults, f"{WNS}pPrDefault")
+
+    ppr = ppr_default.find(f"{WNS}pPr")
+    if ppr is None or len(ppr) == 0:
+        # Empty pPrDefault — add proper defaults
+        if ppr is not None:
+            doc_defaults.remove(ppr_default)
+            ppr_default = ET.SubElement(doc_defaults, f"{WNS}pPrDefault")
+
+        ppr = ET.SubElement(ppr_default, f"{WNS}pPr")
+
+        # Default paragraph spacing (after=200, line=276, lineRule=auto)
+        spacing = ET.SubElement(ppr, f"{WNS}spacing")
+        spacing.set(f"{WNS}after", "200")
+        spacing.set(f"{WNS}line", "276")
+        spacing.set(f"{WNS}lineRule", "auto")
+
+        fixed = True
+
+    return fixed
+
+
+def fix_normal_style(root):
+    """
+    Ensure a proper Normal style exists with w:default="1".
+    Pages needs this as the base paragraph style to correctly resolve
+    inline formatting like center alignment and spacing.
+    """
+    # Check if Normal style already exists
+    for style_el in root.findall(f"{WNS}style"):
+        style_id = style_el.get(f"{WNS}styleId", "")
+        if style_id == "Normal":
+            # Ensure it has w:default="1"
+            if style_el.get(f"{WNS}default") != "1":
+                style_el.set(f"{WNS}default", "1")
+                return True
+            return False
+
+    # Normal style doesn't exist — create it
+    normal = ET.SubElement(root, f"{WNS}style")
+    normal.set(f"{WNS}type", "paragraph")
+    normal.set(f"{WNS}default", "1")
+    normal.set(f"{WNS}styleId", "Normal")
+
+    name = ET.SubElement(normal, f"{WNS}name")
+    name.set(f"{WNS}val", "Normal")
+
+    ET.SubElement(normal, f"{WNS}qFormat")
+
+    # Move it to be the first style (after docDefaults and latentStyles)
+    root.remove(normal)
+    insert_pos = 0
+    for i, child in enumerate(root):
+        tag = child.tag.split("}")[-1] if "}" in child.tag else child.tag
+        if tag in ("docDefaults", "latentStyles"):
+            insert_pos = i + 1
+    root.insert(insert_pos, normal)
+
+    return True
+
+
+def extract_heading_styles_from_document(doc_tree):
+    """
+    Scan document.xml for heading paragraphs and extract their inline formatting.
+    Returns dict: { 'Heading1': { 'color': '6B2D2D', 'sz': '36', ... }, ... }
+    """
+    root = doc_tree.getroot()
+    body = root.find(f".//{WNS}body")
+    if body is None:
+        return {}
+
+    heading_styles = {}
+
+    for para in body.findall(f".//{WNS}p"):
+        p_pr = para.find(f"{WNS}pPr")
+        if p_pr is None:
+            continue
+
+        p_style = p_pr.find(f"{WNS}pStyle")
+        if p_style is None:
+            continue
+        style_id = p_style.get(f"{WNS}val", "")
+        if not style_id.startswith("Heading"):
+            continue
+        if style_id in heading_styles:
+            continue
+
+        fmt = {}
+        # Try inline run properties first (w:r/w:rPr)
+        run = para.find(f"{WNS}r")
+        if run is not None:
+            r_pr = run.find(f"{WNS}rPr")
+            if r_pr is not None:
+                _extract_rpr(r_pr, fmt)
+
+        # Fall back to paragraph default rPr (pPr/rPr)
+        if not fmt:
+            p_rpr = p_pr.find(f"{WNS}rPr")
+            if p_rpr is not None:
+                _extract_rpr(p_rpr, fmt)
+
+        # Extract paragraph spacing
+        spacing = p_pr.find(f"{WNS}spacing")
+        if spacing is not None:
+            before = spacing.get(f"{WNS}before")
+            after = spacing.get(f"{WNS}after")
+            if before:
+                fmt["spacing_before"] = before
+            if after:
+                fmt["spacing_after"] = after
+
+        if fmt:
+            heading_styles[style_id] = fmt
+
+    return heading_styles
+
+
+def _extract_rpr(r_pr, fmt):
+    """Extract formatting properties from a w:rPr element."""
+    color = r_pr.find(f"{WNS}color")
+    if color is not None:
+        fmt["color"] = color.get(f"{WNS}val", "")
+
+    sz = r_pr.find(f"{WNS}sz")
+    if sz is not None:
+        fmt["sz"] = sz.get(f"{WNS}val", "")
+
+    fonts = r_pr.find(f"{WNS}rFonts")
+    if fonts is not None:
+        fmt["font"] = fonts.get(f"{WNS}ascii", "")
+
+    bold = r_pr.find(f"{WNS}b")
+    if bold is not None:
+        fmt["bold"] = True
+
+    italics = r_pr.find(f"{WNS}i")
+    if italics is not None:
+        fmt["italics"] = True
+
+
+def patch_heading_styles(root, heading_styles):
+    """Update heading style definitions with actual formatting from the document."""
+    patched = 0
+
+    for style_el in root.findall(f"{WNS}style"):
+        style_id = style_el.get(f"{WNS}styleId", "")
+        if style_id not in heading_styles:
+            continue
+
+        fmt = heading_styles[style_id]
+
+        # Patch run properties
+        r_pr = style_el.find(f"{WNS}rPr")
+        if r_pr is None:
+            r_pr = ET.SubElement(style_el, f"{WNS}rPr")
+
+        if "color" in fmt:
+            color = r_pr.find(f"{WNS}color")
+            if color is None:
+                color = ET.SubElement(r_pr, f"{WNS}color")
+            color.set(f"{WNS}val", fmt["color"])
+
+        if "sz" in fmt:
+            for tag_name in ["sz", "szCs"]:
+                el = r_pr.find(f"{WNS}{tag_name}")
+                if el is None:
+                    el = ET.SubElement(r_pr, f"{WNS}{tag_name}")
+                el.set(f"{WNS}val", fmt["sz"])
+
+        if "font" in fmt:
+            fonts = r_pr.find(f"{WNS}rFonts")
+            if fonts is None:
+                fonts = ET.SubElement(r_pr, f"{WNS}rFonts")
+            for attr in ["ascii", "hAnsi", "eastAsia", "cs"]:
+                fonts.set(f"{WNS}{attr}", fmt["font"])
+
+        if fmt.get("bold"):
+            if r_pr.find(f"{WNS}b") is None:
+                ET.SubElement(r_pr, f"{WNS}b")
+            if r_pr.find(f"{WNS}bCs") is None:
+                ET.SubElement(r_pr, f"{WNS}bCs")
+
+        if fmt.get("italics"):
+            if r_pr.find(f"{WNS}i") is None:
+                ET.SubElement(r_pr, f"{WNS}i")
+
+        # Patch paragraph spacing
+        if "spacing_before" in fmt or "spacing_after" in fmt:
+            p_pr = style_el.find(f"{WNS}pPr")
+            if p_pr is None:
+                p_pr = ET.SubElement(style_el, f"{WNS}pPr")
+            spacing = p_pr.find(f"{WNS}spacing")
+            if spacing is None:
+                spacing = ET.SubElement(p_pr, f"{WNS}spacing")
+            if "spacing_before" in fmt:
+                spacing.set(f"{WNS}before", fmt["spacing_before"])
+            if "spacing_after" in fmt:
+                spacing.set(f"{WNS}after", fmt["spacing_after"])
+
+        patched += 1
+
+    return patched
+
+
+def fix_styles(input_path, output_path=None):
+    if output_path is None:
+        output_path = input_path
+
+    tmp_dir = tempfile.mkdtemp(prefix="fix_styles_")
+
+    try:
+        extract_dir = os.path.join(tmp_dir, "extracted")
+        with zipfile.ZipFile(input_path, "r") as zf:
+            zf.extractall(extract_dir)
+
+        doc_path = os.path.join(extract_dir, "word", "document.xml")
+        styles_path = os.path.join(extract_dir, "word", "styles.xml")
+
+        if not os.path.exists(doc_path) or not os.path.exists(styles_path):
+            print("Error: Missing document.xml or styles.xml")
+            return
+
+        doc_tree = ET.parse(doc_path)
+        styles_tree = ET.parse(styles_path)
+        styles_root = styles_tree.getroot()
+
+        fixes = []
+
+        # Fix 1: docDefaults
+        if fix_doc_defaults(styles_root):
+            fixes.append("docDefaults")
+
+        # Fix 2: Normal style
+        if fix_normal_style(styles_root):
+            fixes.append("Normal style")
+
+        # Fix 3: Heading styles
+        heading_styles = extract_heading_styles_from_document(doc_tree)
+        if heading_styles:
+            patched = patch_heading_styles(styles_root, heading_styles)
+            if patched:
+                fixes.append(f"{patched} heading style(s)")
+
+        if not fixes:
+            print(f"No fixes needed in {output_path}")
+            return
+
+        # Write back
+        styles_tree.write(styles_path, xml_declaration=True, encoding="UTF-8")
+
+        # Repack
+        tmp_docx = os.path.join(tmp_dir, "output.docx")
+        with zipfile.ZipFile(tmp_docx, "w", zipfile.ZIP_DEFLATED) as zf:
+            for root_dir, _, files in os.walk(extract_dir):
+                for f in files:
+                    full_path = os.path.join(root_dir, f)
+                    arc_name = os.path.relpath(full_path, extract_dir)
+                    zf.write(full_path, arc_name)
+
+        shutil.copy2(tmp_docx, output_path)
+        print(f"Fixed {', '.join(fixes)} in {output_path}")
+
+    finally:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python fix_styles.py input.docx [output.docx]")
+        sys.exit(1)
+
+    input_file = sys.argv[1]
+    output_file = sys.argv[2] if len(sys.argv) > 2 else None
+    fix_styles(input_file, output_file)

package/skills/docx/scripts/fix_tables.py

@@ -76,8 +76,8 @@ def fix_docx(input_path, output_path=None):
     if output_path is None:
         output_path = input_path
 
-    tmp_dir = input_path + '_tmp'
-    os.makedirs(tmp_dir, exist_ok=True)
+    import tempfile
+    tmp_dir = tempfile.mkdtemp(prefix='fix_tables_')
 
     try:
         # Extract