@heylemon/lemonade 0.1.7 → 0.1.8

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.7",
-  "commit": "d184adc6a2e41a87e3e128818c8fb4691ed284fa",
-  "builtAt": "2026-02-21T17:43:41.892Z"
+  "version": "0.1.8",
+  "commit": "afe9f4d0fa565323c39787bae2854ba5905b5a21",
+  "builtAt": "2026-02-21T18:20:37.765Z"
 }

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

@@ -1 +1 @@
-3c0c2fd2a7ea5c555231422230609ed18d2ba0fc3505ef930a0a92cb6a91760e
+38125fabd1c2129cedf329e3c20fd69940046e0859a30f6906f3ff0f944a5aaa

package/package.json

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

package/skills/docx/SKILL.md

@@ -366,7 +366,7 @@ Even if the code is perfect, content matters. Follow these principles:
 ### Callouts
 - Use callouts for key decisions, critical warnings, or bottom-line takeaways.
 - Maximum one per major section — if everything is highlighted, nothing stands out.
-- Format as a highlighted paragraph with accent left border and light background.
+- **Always use paragraph borders** (left border + shading), never narrow table cells as accent stripes. Narrow table cells break in Apple Pages. See "Cross-Platform Compatibility" section.
 
 ---
 
@@ -428,7 +428,23 @@ The validator checks:
 - Empty headings
 - Manual bullet characters (should use List APIs)
 
-### 2. Visual Check (PDF Conversion)
+### 2. Fix Tables for Cross-Platform (MANDATORY if document contains tables)
+
+docx-js has a bug where table grid definitions (`tblGrid`) don't match cell widths. This causes tables to render as 1-character-wide columns in Apple Pages, Google Docs, and LibreOffice. Run this fix on every document that contains tables:
+
+```bash
+python scripts/fix_tables.py report.docx
+```
+
+This script:
+- Reads each table's first-row cell widths (`tcW`)
+- Patches the `tblGrid` column definitions to match
+- Adds `tblLayout type="fixed"` for consistent rendering
+- Overwrites the file in place (or pass a second arg for a new file)
+
+**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)
 
 ```bash
 # Convert to PDF
@@ -440,13 +456,14 @@ pdftoppm -jpeg -r 150 report.pdf page
 # View: page-1.jpg, page-2.jpg, etc.
 ```
 
-### 3. Fix & Re-validate
+### 4. 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. Re-validate with `validate.py`
-4. Re-convert to PDF if visual issues
+3. Run `fix_tables.py` again (step 2)
+4. Re-validate with `validate.py`
+5. Re-convert to PDF if visual issues
 
 Iterate until both validation passes and visual output looks polished.
 
@@ -591,6 +608,85 @@ sudo apt-get install libreoffice poppler-utils  # soffice, pdftoppm
 
 ---
 
+## Cross-Platform Compatibility (Pages, Google Docs, LibreOffice)
+
+Documents must look correct in Apple Pages, Google Docs, and LibreOffice — not just Microsoft Word. These apps interpret .docx features differently and many advanced Word features break silently.
+
+### Features That Break in Pages
+
+**Narrow decorative table cells (< 200 DXA):**
+Pages collapses very narrow cells, causing adjacent text to render vertically (one character per line). This is the most common Pages rendering bug.
+
+- ❌ **Never:** Use a 120 DXA cell as a colored accent stripe next to a content cell
+- ❌ **Never:** Use single-cell tables as horizontal rule/divider decorations
+- ✅ **Instead:** Use paragraph borders for accent effects:
+
+```javascript
+// Callout box — cross-platform safe
+// Uses left border on the paragraph itself, not a narrow table cell
+new Paragraph({
+    spacing: { before: 200, after: 200 },
+    indent: { left: 360 },
+    border: {
+        left: { style: BorderStyle.SINGLE, size: 12, color: "2E86AB", space: 10 }
+    },
+    shading: { fill: "E8F4F8", type: ShadingType.CLEAR },
+    children: [
+        new TextRun({ text: "Decision needed: ", bold: true, size: 22, color: "1B3A5C" }),
+        new TextRun({ text: "Approve the $400K budget by February 28.", size: 22, color: "2C3E50" })
+    ]
+})
+```
+
+**Decorative tables as horizontal lines:**
+```javascript
+// ❌ BREAKS in Pages — tiny table used as accent line
+new Table({
+    width: { size: 2880, type: WidthType.DXA },
+    rows: [new TableRow({ children: [new TableCell({
+        width: { size: 2880, type: WidthType.DXA },
+        shading: { fill: "2E86AB", type: ShadingType.CLEAR },
+        children: [new Paragraph({ children: [new TextRun({ text: " ", size: 4 })] })]
+    })] })]
+})
+
+// ✅ WORKS everywhere — paragraph bottom border as accent line
+new Paragraph({
+    spacing: { after: 200 },
+    border: {
+        bottom: { style: BorderStyle.SINGLE, size: 6, color: "2E86AB", space: 8 }
+    },
+    children: []  // Empty paragraph with just a bottom border
+})
+```
+
+### Other Cross-Platform Pitfalls
+
+- **Text boxes / floating elements**: Pages and Google Docs don't support them — content disappears or overlaps
+- **Custom XML / content controls**: Ignored by non-Word apps
+- **Complex nested tables**: Keep nesting to 1 level max; Pages handles deeply nested tables poorly
+- **Tab stops for alignment**: Use tables instead — tab rendering varies between apps
+- **Form fields**: Only work in Word
+- **Watermarks**: Render differently or not at all in Pages
+- **SmartArt / ActiveX**: Not supported outside Word
+
+### Safe Cross-Platform Features
+
+These features render consistently across all apps:
+- Simple tables with explicit cell widths (minimum 400 DXA per cell)
+- Paragraph borders (left, bottom, top — great for callouts and dividers)
+- Paragraph shading/highlighting
+- Bold, italic, underline, font color, font size
+- Heading styles (Heading 1-6)
+- Bullet and numbered lists
+- Page breaks
+- Headers and footers with page numbers
+- Images (inline, not floating)
+
+### The 400 DXA Rule
+
+**Never create a table cell narrower than 400 DXA (roughly 0.28 inches).** Cells below this width are rendered unpredictably in Pages and LibreOffice. If you need a thin accent stripe, use a paragraph left border instead.
+
 ## Troubleshooting
 
 **Document won't open in Word:** XML malformed. Check for unclosed tags, invalid characters. Run `validate.py` to check structure.
@@ -603,6 +699,8 @@ sudo apt-get install libreoffice poppler-utils  # soffice, pdftoppm
 
 **TOC not generating:** docx-js doesn't support field codes natively. Use placeholder text or manually update in Word after opening.
 
+**Text renders vertically in Pages:** A table cell is too narrow (< 200 DXA). Replace narrow decorative cells with paragraph borders. See "Cross-Platform Compatibility" section above.
+
 ---
 
 ## Example: Simple Report

package/skills/docx/scripts/fix_tables.py

@@ -0,0 +1,118 @@
+"""
+Post-process a docx-js generated .docx file to fix tblGrid values for Pages compatibility.
+
+docx-js generates <w:gridCol w:w="100"/> for all columns regardless of actual cell widths.
+Pages relies on tblGrid for layout, so tables render as 1-char-wide columns.
+This script reads the tcW values from each table's first row and patches tblGrid to match.
+"""
+import sys
+import zipfile
+import os
+import re
+import shutil
+from lxml import etree
+
+WORD_NS = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'
+NSMAP = {'w': WORD_NS}
+
+def fix_tables(xml_content):
+    """Fix tblGrid values to match first-row cell widths."""
+    root = etree.fromstring(xml_content)
+    tables = root.findall('.//w:tbl', NSMAP)
+    fixes = 0
+
+    for tbl in tables:
+        grid = tbl.find('w:tblGrid', NSMAP)
+        if grid is None:
+            continue
+
+        # Get first row's cell widths
+        first_row = tbl.find('w:tr', NSMAP)
+        if first_row is None:
+            continue
+
+        cells = first_row.findall('w:tc', NSMAP)
+        cell_widths = []
+        for tc in cells:
+            tcPr = tc.find('w:tcPr', NSMAP)
+            if tcPr is not None:
+                tcW = tcPr.find('w:tcW', NSMAP)
+                if tcW is not None:
+                    w_val = tcW.get(f'{{{WORD_NS}}}w')
+                    w_type = tcW.get(f'{{{WORD_NS}}}type', 'dxa')
+                    if w_type == 'dxa' and w_val:
+                        try:
+                            cell_widths.append(int(w_val))
+                        except ValueError:
+                            cell_widths.append(2340)  # default fallback
+                    else:
+                        cell_widths.append(2340)
+                else:
+                    cell_widths.append(2340)
+            else:
+                cell_widths.append(2340)
+
+        # Check if grid needs fixing (all gridCol are 100 = docx-js default)
+        grid_cols = grid.findall('w:gridCol', NSMAP)
+        all_100 = all(gc.get(f'{{{WORD_NS}}}w') == '100' for gc in grid_cols)
+
+        if all_100 and len(cell_widths) == len(grid_cols):
+            for gc, width in zip(grid_cols, cell_widths):
+                gc.set(f'{{{WORD_NS}}}w', str(width))
+            fixes += 1
+
+        # Also ensure tblLayout is set to fixed for Pages
+        tblPr = tbl.find('w:tblPr', NSMAP)
+        if tblPr is not None:
+            layout = tblPr.find('w:tblLayout', NSMAP)
+            if layout is None:
+                layout = etree.SubElement(tblPr, f'{{{WORD_NS}}}tblLayout')
+                layout.set(f'{{{WORD_NS}}}type', 'fixed')
+
+    return etree.tostring(root, xml_declaration=True, encoding='UTF-8', standalone=True), fixes
+
+def fix_docx(input_path, output_path=None):
+    """Fix a .docx file's table grids for Pages compatibility."""
+    if output_path is None:
+        output_path = input_path
+
+    tmp_dir = input_path + '_tmp'
+    os.makedirs(tmp_dir, exist_ok=True)
+
+    try:
+        # Extract
+        with zipfile.ZipFile(input_path, 'r') as z:
+            z.extractall(tmp_dir)
+
+        # Fix document.xml
+        doc_path = os.path.join(tmp_dir, 'word', 'document.xml')
+        with open(doc_path, 'rb') as f:
+            xml_content = f.read()
+
+        fixed_xml, num_fixes = fix_tables(xml_content)
+
+        with open(doc_path, 'wb') as f:
+            f.write(fixed_xml)
+
+        # Repack
+        with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zout:
+            for root_dir, dirs, files in os.walk(tmp_dir):
+                for file in files:
+                    file_path = os.path.join(root_dir, file)
+                    arcname = os.path.relpath(file_path, tmp_dir)
+                    zout.write(file_path, arcname)
+
+        print(f"Fixed {num_fixes} table(s) in {output_path}")
+        return num_fixes
+
+    finally:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print("Usage: python fix_docx_tables.py <input.docx> [output.docx]")
+        sys.exit(1)
+
+    input_file = sys.argv[1]
+    output_file = sys.argv[2] if len(sys.argv) > 2 else input_file
+    fix_docx(input_file, output_file)

package/skills/pptx/SKILL.md

@@ -96,6 +96,57 @@ Use one font pairing for the entire deck. Consistency.
 - Never center body text (left-align only)
 - Use `paraSpaceAfter: 6` for bullet spacing, never `lineSpacing`
 
+### Slide Boundary Rules (CRITICAL — Content Overflow)
+
+**Nothing may extend beyond the slide edges.** Content that overflows is invisible — it gets cut off and looks broken in presentation mode.
+
+Standard 16:9 slide dimensions: **10" wide × 5.625" tall**
+
+Every element must satisfy these constraints:
+- `x + w ≤ 10` (right edge)
+- `y + h ≤ 5.625` (bottom edge)
+- `x ≥ 0` and `y ≥ 0` (top-left origin)
+
+**Before placing any element, calculate remaining space:**
+```
+available_height = 5.625 - current_y - 0.5   // 0.5" bottom margin
+```
+
+If content doesn't fit, you MUST do one of these (in order of preference):
+1. **Split across two slides** — A second slide is always better than overflow
+2. **Reduce font sizes** — Body → 12pt, stats → 48pt instead of 60pt, title → 18pt
+3. **Remove items** — Fewer bullets, fewer cards. Less is more
+4. **Tighten spacing** — Reduce gaps between elements to 0.2" minimum
+
+**Safe content zones (with 0.5" margins):**
+```
+Title area:     y = 0.5,  h = 0.6
+Content start:  y = 1.2
+Content end:    y = 5.1   (0.5" bottom margin)
+Usable content height: 3.9 inches — plan ALL layouts within this
+```
+
+**Layout height budgets — know these before coding:**
+
+| Layout Type | Title | Content Area | Max Items |
+|---|---|---|---|
+| Bullet list | 0.7" | 3.9" | 8 bullets max (0.35" each) |
+| 2-column bullets | 0.7" | 3.9" | 5 bullets per column |
+| Stat cards (1 row) | 0.7" | 1.8" for cards | 3-4 cards |
+| Stat cards (2 rows) | 0.7" | 3.4" for cards | 6-8 cards |
+| Comparison (side-by-side) | 0.7" | 3.2" max per card | 4 bullets per card |
+| Table | 0.7" | 3.9" | 7 rows max (0.4" per row) |
+| Title + subtitle + cards | 1.2" | 3.4" | 3 cards |
+
+**Common overflow traps:**
+- **Comparison layouts** — Two side-by-side cards are taller than you think. Budget 2.5-3" max per card, not 3.5". If each card has a title + 5 bullets, it needs ~3" minimum — split to two slides
+- **Bullet lists with 6+ items** — Each bullet needs ~0.35". Six bullets = 2.1". Add title + spacing = 3.5"+
+- **Stat cards stacked in 2 rows** — stat (60pt) + label (12pt) + padding = ~1.5" per row. Two rows + title = 4" before you add anything else
+- **Tables with 5+ rows** — Header + 5 data rows = ~2.4". Add title + margins = 3.5"
+- **"Just one more element"** — Adding a footnote, source line, or page number below a full slide. Check remaining space first
+
+**Validation rule: After writing code for any slide, mentally verify that the lowest element's `y + h` does not exceed 5.5 inches (leaving 0.125" safety margin). If it does, refactor before moving to the next slide.**
+
 ### What to Avoid
 
 - **Don't repeat the same layout** — Two content slides in a row can feel monotonous. Vary between text-heavy, stat cards, comparisons, and two-column layouts.
@@ -104,6 +155,7 @@ Use one font pairing for the entire deck. Consistency.
 - **Don't default to blue** — Blue is overdone. It's the safe choice. Pick a palette that matches the content's emotional tone.
 - **Never add accent lines under titles** — This is the hallmark of AI-generated slides. If you add an underline, make it purposeful (color bar on stat cards) not decorative.
 - **Don't create text-only slides** — Every slide needs at least one visual anchor: a stat card, an accent color, an icon, or a highlighted quote.
+- **Never let content overflow the slide** — If `y + h > 5.625`, content is cut off. Always calculate remaining space before placing elements. See "Slide Boundary Rules" above.
 
 ## QA Process
 

package/skills/pptx/pptxgenjs.md

@@ -29,16 +29,28 @@ Key point: Always create a fresh `PptxGenJS()` instance per presentation. Don't
 Standard 16:9 layout is 10 inches wide by 5.625 inches tall. All positioning is in inches.
 
 ```javascript
-// Slide area
-const W = 10;          // Width
-const H = 5.625;       // Height
+// Slide area — HARD LIMITS (nothing may exceed these)
+const W = 10;          // Width (inches)
+const H = 5.625;       // Height (inches)
 const M = 0.5;         // Margin (standard)
-const contentWidth = W - 2 * M;  // 9 inches
+const contentWidth = W - 2 * M;  // 9 inches usable
 
 // Common positioning
-const titleY = M;           // Top margin
-const contentStartY = M + 0.8;  // After title
-const bottomY = H - 0.8;    // Near bottom for footer
+const titleY = M;                // Top margin
+const contentStartY = M + 0.8;  // After title (y = 1.3)
+const maxContentY = H - M;      // 5.125 — absolute bottom of content
+const contentHeight = maxContentY - contentStartY;  // ~3.8" available
+
+// BOUNDARY CHECK — use before placing every element:
+// if (elementY + elementH > H) → content will overflow, reduce or split slide
+```
+
+**CRITICAL: Every element must satisfy `y + h ≤ 5.625`.** If an element's bottom edge exceeds the slide height, it will be cut off in presentation mode. Always calculate remaining space before placing elements:
+```javascript
+const remainingHeight = H - currentY - M;  // available space below current position
+if (cardHeight > remainingHeight) {
+    // Split to next slide or reduce content
+}
 ```
 
 ## Text & Formatting
@@ -622,3 +634,33 @@ slide.addText([
 
 pres.writeFile({ fileName: "output.pptx" });
 ```
+
+## Common Pitfalls: Stat Cards & Large Numbers
+
+**Large numbers overflow their text boxes.** At 48pt+ with bold fonts like Arial Black, values like "12.4K", "$156K", or "$48K" are often wider than narrow card text boxes (2-3 inches). When they overflow, the text wraps and produces broken-looking results — e.g. "12.4" on one line and "K" huge on the next.
+
+**Always use `shrinkText: true` on stat values:**
+```javascript
+slide.addText("$156K", {
+    x: cardX, y: cardY + 0.5, w: cardW, h: 1,
+    fontSize: 52,
+    fontFace: "Arial Black",
+    color: accentColor,
+    bold: true,
+    align: "center",
+    valign: "middle",
+    shrinkText: true  // CRITICAL — auto-scales text to fit the box
+});
+```
+
+This tells PowerPoint to auto-shrink the font size if the text doesn't fit. It's invisible when text fits fine, but prevents wrapping when values are wider than expected.
+
+**When to use `shrinkText: true`:**
+- All stat card values (any font ≥ 36pt in a box < 3" wide)
+- Slide titles on section dividers (large font + long titles)
+- Any text box where the content length is unpredictable
+
+**Alternative approaches if `shrinkText` isn't sufficient:**
+- Reduce font size for longer values: `fontSize: value.length > 4 ? 40 : 52`
+- Widen cards: use 3 cards per row instead of 4
+- Abbreviate values: "$156K" instead of "$156,000"

package/skills/pptx/scripts/create_pptx.js

@@ -8,8 +8,8 @@
  * JSON spec format: see references/spec-format.md
  */
 
-import pptxgen from "pptxgenjs";
-import fs from "node:fs";
+const pptxgen = require("pptxgenjs");
+const fs = require("fs");
 
 // ═══════════════════════════════════════════
 // DEFAULT THEME