@heylemon/lemonade 0.5.9 → 0.6.0

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.9",
-  "commit": "afa819caa1ebbbf3880064fe1ff0a3477acf29ba",
-  "builtAt": "2026-02-27T08:16:50.523Z"
+  "version": "0.6.0",
+  "commit": "3e86276898dcac0ab6e58fb3fd5732fe712d069a",
+  "builtAt": "2026-02-27T09:13:13.678Z"
 }

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

@@ -1 +1 @@
-5c0b19b1e764a81d2372636e26464b4ed27af3661042686be3fd49e82f6ea289
+c7c3dae0b04843ef55701aa1424c692bd8fd4a90bdea1187fb53373a6da54271

package/package.json

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

package/skills/docx/SKILL.md

@@ -205,49 +205,78 @@ new Paragraph({
 })
 ```
 
-### Tables: Dual Width Rules (CRITICAL)
+### Tables: Width Rules (CRITICAL)
 
-Tables MUST specify width in two places. Always use `WidthType.DXA`, never PERCENTAGE:
+Tables need width at two levels:
+1. **Table level:** `WidthType.PERCENTAGE` (100%) for the outer container
+2. **Cell level:** `WidthType.DXA` for every individual cell — never PERCENTAGE on cells
+
+Cell widths MUST sum to the content area width. With 1-inch margins on US Letter:
+- Content width = 8.5" - 2" = 6.5" = **9360 DXA**
+- Divide 9360 among your columns (e.g., 3 cols: 3000 + 3000 + 3360 = 9360)
+
+**Every row must use the same cell widths for each column.** Do not vary widths between rows — this causes misaligned columns in Pages and Google Docs. Define your column widths once and reuse them:
 
 ```javascript
+// Define column widths ONCE — reuse for every row
+const COL_WIDTHS = [3000, 3000, 3360]; // Must sum to 9360
+
 new Table({
   width: {
     size: 100,
-    type: WidthType.PERCENTAGE  // Table width = 100% of content area
+    type: WidthType.PERCENTAGE  // Table stretches to content area
   },
   rows: [
+    // Header row
     new TableRow({
       children: [
         new TableCell({
-          width: { size: 2000, type: WidthType.DXA },  // Individual cell width in DXA
-          children: [ new Paragraph("Header 1") ]
+          width: { size: COL_WIDTHS[0], type: WidthType.DXA },
+          shading: { fill: "1B3A5C", type: ShadingType.CLEAR },
+          children: [new Paragraph({ children: [new TextRun({ text: "Category", bold: true, color: "FFFFFF", size: 22 })] })]
         }),
         new TableCell({
-          width: { size: 2500, type: WidthType.DXA },
-          children: [ new Paragraph("Header 2") ]
+          width: { size: COL_WIDTHS[1], type: WidthType.DXA },
+          shading: { fill: "1B3A5C", type: ShadingType.CLEAR },
+          children: [new Paragraph({ children: [new TextRun({ text: "Q3 Revenue", bold: true, color: "FFFFFF", size: 22 })] })]
         }),
         new TableCell({
-          width: { size: 2000, type: WidthType.DXA },
-          children: [ new Paragraph("Header 3") ]
+          width: { size: COL_WIDTHS[2], type: WidthType.DXA },
+          shading: { fill: "1B3A5C", type: ShadingType.CLEAR },
+          children: [new Paragraph({ children: [new TextRun({ text: "Growth YoY", bold: true, color: "FFFFFF", size: 22 })] })]
         })
       ]
     }),
-    // Data rows follow
+    // Data row — same COL_WIDTHS
     new TableRow({
       children: [
         new TableCell({
-          width: { size: 2000, type: WidthType.DXA },
+          width: { size: COL_WIDTHS[0], type: WidthType.DXA },
           shading: { fill: "E8F4F8", type: ShadingType.CLEAR },
-          children: [ new Paragraph("Data 1") ]
+          children: [new Paragraph({ children: [new TextRun({ text: "Enterprise", size: 22 })] })]
         }),
-        // ... more cells
+        new TableCell({
+          width: { size: COL_WIDTHS[1], type: WidthType.DXA },
+          shading: { fill: "E8F4F8", type: ShadingType.CLEAR },
+          children: [new Paragraph({ children: [new TextRun({ text: "$2.1M", size: 22 })] })]
+        }),
+        new TableCell({
+          width: { size: COL_WIDTHS[2], type: WidthType.DXA },
+          shading: { fill: "E8F4F8", type: ShadingType.CLEAR },
+          children: [new Paragraph({ children: [new TextRun({ text: "34%", size: 22 })] })]
+        })
       ]
     })
   ]
 });
 ```
 
-Cell widths must sum to total table width. 6.5 inches of content (8.5 - 2 margins) = ~9360 DXA.
+**Common table width breakdowns (all sum to 9360 DXA):**
+- 2 columns: 4680 + 4680
+- 3 columns: 3120 + 3120 + 3120
+- 4 columns: 2340 + 2340 + 2340 + 2340
+- 5 columns: 1872 + 1872 + 1872 + 1872 + 1872
+- Uneven: 2400 + 4560 + 2400 (wider middle column)
 
 ### Cell Shading (Background Colors)
 
@@ -362,7 +391,8 @@ Or use a more sophisticated approach with field codes (requires XML manipulation
 - Create separate Paragraph objects for each paragraph (never use \n)
 - Use List APIs for bullets/numbers (never hardcode • or -)
 - Always include `type` parameter on ImageRun
-- Set both table width AND individual cell widths in DXA
+- Set table width to 100% PERCENTAGE, and all cell widths in DXA summing to 9360
+- Use the same cell widths for each column across ALL rows
 - Use `ShadingType.CLEAR` for cell backgrounds
 - Use `HeadingLevel.HEADING_1`, etc., with `outlineLevel` for TOC
 - Use `children` with TextRun for headings, NOT the `run` property (Pages ignores `run`)
@@ -372,7 +402,8 @@ Or use a more sophisticated approach with field codes (requires XML manipulation
 
 **DON'T:**
 - Use newlines (\n) — create separate Paragraphs instead
-- Mix WidthType.PERCENTAGE and WidthType.DXA on different table cells
+- Use WidthType.PERCENTAGE on individual cells (only on the table container)
+- Use different cell widths for the same column in different rows
 - Omit `type` on ImageRun (causes runtime errors)
 - Use unicode bullet characters manually
 - Put PageBreak outside a Paragraph
@@ -757,7 +788,7 @@ These features render consistently across all apps:
 
 **Document won't open in Word:** XML malformed. Check for unclosed tags, invalid characters. Run `validate.py` to check structure.
 
-**Tables look misaligned:** Missing cell widths or inconsistent width types. Ensure every cell has `width: { size: X, type: WidthType.DXA }`.
+**Tables look misaligned:** Three common causes: (1) Missing cell widths — ensure every cell has `width: { size: X, type: WidthType.DXA }`. (2) Inconsistent widths across rows — every row must use the same width for each column. (3) Cell widths don't sum to 9360 DXA — recalculate so they add up exactly. Also ensure `fix_tables.py` was run after generation.
 
 **Page breaks in wrong place:** PageBreak must be inside Paragraph. `new Paragraph({ children: [new PageBreak()] })`.
 

package/skills/docx/scripts/fix_tables.py

@@ -3,20 +3,120 @@ Post-process a docx-js generated .docx file to fix tblGrid values for Pages comp
 
 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.
+This script reads the tcW values from each table's rows (handling gridSpan for merged cells)
+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 get_cell_span(tc):
+    """Get the gridSpan value for a cell (defaults to 1 if not set)."""
+    tcPr = tc.find('w:tcPr', NSMAP)
+    if tcPr is not None:
+        gridSpan = tcPr.find('w:gridSpan', NSMAP)
+        if gridSpan is not None:
+            val = gridSpan.get(f'{{{WORD_NS}}}val')
+            if val:
+                try:
+                    return int(val)
+                except ValueError:
+                    pass
+    return 1
+
+
+def get_cell_width(tc, default=2340):
+    """Get the DXA width for a cell."""
+    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:
+                    return int(w_val)
+                except ValueError:
+                    pass
+    return default
+
+
+def resolve_column_widths(tbl, num_grid_cols):
+    """
+    Scan all rows to determine individual column widths.
+    Handles gridSpan (merged cells) by finding a row where each column
+    appears unmerged, or by splitting merged widths evenly.
+    """
+    col_widths = [None] * num_grid_cols
+
+    rows = tbl.findall('w:tr', NSMAP)
+    for tr in rows:
+        cells = tr.findall('w:tc', NSMAP)
+        col_idx = 0
+        for tc in cells:
+            span = get_cell_span(tc)
+            width = get_cell_width(tc)
+
+            if span == 1 and col_idx < num_grid_cols:
+                if col_widths[col_idx] is None:
+                    col_widths[col_idx] = width
+            elif span > 1:
+                # Merged cell -- split width evenly if we haven't resolved these columns yet
+                per_col = width // span
+                remainder = width - (per_col * span)
+                for i in range(span):
+                    target = col_idx + i
+                    if target < num_grid_cols and col_widths[target] is None:
+                        col_widths[target] = per_col + (1 if i < remainder else 0)
+
+            col_idx += span
+
+        # Stop early if all columns are resolved
+        if all(w is not None for w in col_widths):
+            break
+
+    # Fill any remaining None values with a reasonable default
+    for i in range(num_grid_cols):
+        if col_widths[i] is None:
+            col_widths[i] = 2340
+
+    return col_widths
+
+
+def grid_needs_fix(grid_cols):
+    """Check if the tblGrid looks like a docx-js default that needs patching."""
+    if not grid_cols:
+        return False
+    values = []
+    for gc in grid_cols:
+        val = gc.get(f'{{{WORD_NS}}}w')
+        if val:
+            try:
+                values.append(int(val))
+            except ValueError:
+                return True
+        else:
+            return True
+
+    # Fix if all values are identical small numbers (docx-js default is 100)
+    if len(set(values)) == 1 and values[0] <= 200:
+        return True
+
+    # Fix if total grid width is unreasonably small (< 1000 DXA for a multi-column table)
+    if len(values) > 1 and sum(values) < 1000:
+        return True
+
+    return False
+
+
 def fix_tables(xml_content):
-    """Fix tblGrid values to match first-row cell widths."""
+    """Fix tblGrid values to match actual cell widths."""
     root = etree.fromstring(xml_content)
     tables = root.findall('.//w:tbl', NSMAP)
     fixes = 0
@@ -26,42 +126,21 @@ def fix_tables(xml_content):
         if grid is None:
             continue
 
-        # Get first row's cell widths
-        first_row = tbl.find('w:tr', NSMAP)
-        if first_row is None:
+        grid_cols = grid.findall('w:gridCol', NSMAP)
+        if not grid_cols:
             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)
+        num_grid_cols = len(grid_cols)
+
+        if grid_needs_fix(grid_cols):
+            col_widths = resolve_column_widths(tbl, num_grid_cols)
 
-        if all_100 and len(cell_widths) == len(grid_cols):
-            for gc, width in zip(grid_cols, cell_widths):
+            # Update gridCol values
+            for gc, width in zip(grid_cols, col_widths):
                 gc.set(f'{{{WORD_NS}}}w', str(width))
             fixes += 1
 
-        # Also ensure tblLayout is set to fixed for Pages
+        # Ensure tblLayout is set to fixed for consistent rendering
         tblPr = tbl.find('w:tblPr', NSMAP)
         if tblPr is not None:
             layout = tblPr.find('w:tblLayout', NSMAP)
@@ -71,6 +150,7 @@ def fix_tables(xml_content):
 
     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:
@@ -80,11 +160,9 @@ def fix_docx(input_path, output_path=None):
     tmp_dir = tempfile.mkdtemp(prefix='fix_tables_')
 
     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()
@@ -94,7 +172,6 @@ def fix_docx(input_path, output_path=None):
         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:
@@ -108,9 +185,10 @@ def fix_docx(input_path, output_path=None):
     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]")
+        print("Usage: python fix_tables.py <input.docx> [output.docx]")
         sys.exit(1)
 
     input_file = sys.argv[1]