@heylemon/lemonade 0.1.6 → 0.1.7

package/skills/xlsx/references/spec-format.md

@@ -1,53 +1,251 @@
-# Spreadsheet Spec Format
+# Financial Model Standards
 
-## Top Level
+Professional Excel financial models follow industry conventions for colors, formatting, and structure. These standards ensure models are readable, auditable, and suitable for investor presentations.
+
+## Color Coding Reference
+
+All financial models use consistent color coding for cell types:
+
+| Color | Meaning | Cell Type | RGB (Excel) | Example |
+|---|---|---|---|---|
+| Blue text | Input values | Hardcoded numbers user changes | (0, 0, 255) | Revenue growth rates, unit prices |
+| Black text | Formulas | Calculated values | (0, 0, 0) | SUM totals, margin calculations |
+| Green text | Cross-sheet references | Formulas linking other sheets | (0, 128, 0) | Pulling actuals from Data sheet |
+| Red text | External references | Data from outside sources | (255, 0, 0) | Market data, benchmark rates |
+| Yellow background | Key assumptions | Critical driver cells | Yellow | Growth rate, discount rate, conversion |
+
+## Number Formatting Conventions
+
+Apply these formats to match industry standards and improve readability:
+
+| Data Type | Format String | Example | Use Case |
+|---|---|---|---|
+| Currency (standard) | `$#,##0` | $45,000 | Individual amounts |
+| Currency (thousands) | `$#,##0,"K"` | $45K | Large amounts, summaries |
+| Currency (millions) | `$#,##0,,"M"` | $1,245M | Very large amounts |
+| Percentage | `0.0%` | 15.2% | Margins, growth rates |
+| Percentage (no decimals) | `0%` | 15% | When precision not needed |
+| Multiples | `0.0x` | 3.2x | Revenue multiples, LTV/CAC |
+| Years (text) | Text format | 2026 | Period headers (never 2,026) |
+| Zero display | `_($* #,##0_);_($* (#,##0);_($* "-"_);_(@_)` | – | Display zeros as dashes |
+| Negatives in parens | `($#,##0)` | ($5,000) | Cash flows, deficits |
+
+## Cell Types by Use Case
+
+### Revenue/Income Statement Model
+
+```
+Row 1:  [Metric]              [2024A]    [2025E]    [2026E]
+Row 2:  Revenue ($K)          [1000]     [1500]     [2100]      <- Blue inputs
+Row 3:  Growth Rate           —          50%        40%         <- Blue inputs + Yellow bg
+Row 4:  COGS ($K)             [400]      [600]      [820]       <- Formulas (black)
+Row 5:  Gross Margin %        40.0%      40.0%      39.0%       <- Blue inputs + Yellow bg
+Row 6:  OpEx ($K)             [300]      [350]      [420]       <- Blue inputs
+Row 7:  EBITDA ($K)           [300]      [550]      [860]       <- Formulas (black)
+Row 8:  EBITDA Margin         30.0%      36.7%      41.0%       <- Formulas (black)
+```
+
+### Cash Flow Model
+
+```
+Row 1:  [Item]                [Month 1]  [Month 2]  [Month 3]
+Row 2:  Beginning Cash        [100,000]  [formula]  [formula]   <- Blue for Month 1, black after
+Row 3:  Operating Cash In     [50,000]   [50,000]   [60,000]    <- Blue inputs
+Row 4:  Operating Cash Out    [30,000]   [28,000]   [32,000]    <- Blue inputs
+Row 5:  Operating Cash Flow   [formula]  [formula]  [formula]   <- Formulas (black)
+Row 6:  Capex                 [10,000]   [10,000]   [—]         <- Blue inputs
+Row 7:  Ending Cash           [formula]  [formula]  [formula]   <- Formulas (black)
+```
+
+### 3-Statement Waterfall Model
 
-```json
-{
-  "brand": {},
-  "sheets": []
-}
 ```
+                   [2024A]    [2025E]    [2026E]
+Income Statement
+  Revenue          1000       1500       2100        <- Blue inputs
+  COGS             -400       -600       -820        <- Formulas (black) or blue
+  Operating Exp    -300       -350       -420        <- Blue inputs
+  EBITDA            300        550        860        <- Formulas (black)
+  D&A              -50         -50        -50        <- Blue inputs
+  EBIT              250        500        810        <- Formulas (black)
+  Interest         -25         -25        -20        <- Blue inputs or formulas
+  PBT               225        475        790        <- Formulas (black)
+  Tax (35%)        -79         -166       -277       <- Formulas (black)
+  Net Income        146        309        513        <- Formulas (black)
 
-## Sheet Types
+Balance Sheet
+  Cash             100        300        [formula]   <- Blue or cross-sheet link (green)
+  AR               [formula]  [formula]  [formula]   <- Formulas based on sales
+  Assets           [formula]  [formula]  [formula]   <- Formulas (sum)
+  AP               [formula]  [formula]  [formula]   <- Formulas based on COGS
+  Debt             500        400        [formula]   <- Blue or calculation
+  Equity           [formula]  [formula]  [formula]   <- Formulas
 
-### data
+Cash Flow
+  Operating CF     [formula]  [formula]  [formula]   <- Formulas from I/S + BS changes
+  Investing CF     -100       -100       -150        <- Blue inputs (capex)
+  Financing CF     [formula]  [formula]  [formula]   <- Formulas (debt/equity changes)
+  Net Cash Change  [formula]  [formula]  [formula]   <- Formulas (sum of above)
+```
+
+## Assumptions Sheet Structure
+
+Always create a dedicated "Assumptions" sheet:
+
+```
+Row 1:  [Category]              [Value]         [Comment]
+Row 2:  ========== FINANCIAL DRIVERS ==========
+Row 3:  Revenue Growth          50%             <- Blue input + yellow bg
+Row 4:  Gross Margin            40.0%           <- Blue input + yellow bg
+Row 5:  Tax Rate                35.0%           <- Blue input + yellow bg
+Row 6:
+Row 7:  ========== BALANCE SHEET DRIVERS ==========
+Row 8:  Days Sales Outstanding  45              <- Blue input + yellow bg
+Row 9:  Days Payable            30              <- Blue input + yellow bg
+Row 10: Capex as % of Revenue   5%              <- Blue input + yellow bg
+Row 11:
+Row 12: ========== WORKING CAPITAL ==========
+Row 13: AR Days                 45              <- Blue input
+Row 14: Inventory Days          30              <- Blue input
+Row 15: AP Days                 30              <- Blue input
+```
+
+## Formula Best Practices
+
+### Hardcoded vs. Referenced
 
-```json
-{
-  "name": "Sales Data",
-  "type": "data",
-  "title": "Q1 2026 Sales Pipeline",
-  "headers": ["Deal", "Stage", "Value", "Close Date", "Owner"],
-  "rows": [["Acme", "Negotiation", 45000, "2026-03-15", "Sarah"]],
-  "freeze_panes": "A2",
-  "auto_filter": true,
-  "formulas": [{"cell": "C50", "formula": "=SUM(C2:C49)", "bold": true}]
-}
+**WRONG** — Constants baked into formulas:
+```
+C4 = C2 * 0.40          (hardcoded 40% margin)
+D7 = C7 + C7 * 0.15     (hardcoded 15% tax rate)
+```
+
+**RIGHT** — References to assumption cells:
+```
+C4 = C2 * $B$5          (references cell B5: Gross Margin)
+D7 = C7 + C7 * $B$6     (references cell B6: Tax Rate)
 ```
 
-### dashboard
+Use absolute references ($B$5) for constants so they don't shift when copying formulas.
+
+### Cross-Sheet References
+
+Format: `='Sheet Name'!Cell`
 
-```json
-{
-  "name": "Dashboard",
-  "type": "dashboard",
-  "title": "Q1 Performance Dashboard",
-  "kpis": [{"value": "$156K", "label": "Monthly Revenue", "change": "+32%"}],
-  "sections": [{"title": "Top Deals", "headers": ["Client", "Value"], "rows": [["Enterprise Co", "$120K"]]}]
-}
 ```
+=SUM('P&L'!B7:B100)     (Sum from P&L sheet)
+='Assumptions'!B3       (Pull growth rate from assumptions)
+```
+
+### Handling Zeros and Blanks
 
-### financial
+Avoid errors with defensive formulas:
 
-```json
-{
-  "name": "Financial Model",
-  "type": "financial",
-  "headers": ["", "2024A", "2025E", "2026E"],
-  "rows": [["Revenue", 480, 960, 1920]],
-  "input_cells": ["B2"],
-  "assumption_cells": ["C2"],
-  "formulas": [{"cell": "D2", "formula": "=C2*(1+C3)"}]
-}
 ```
+=IF(B2=0, 0, A2/B2)                 (Guard division by zero)
+=IF(ISBLANK(B2), 0, B2 * C2)        (Handle missing data)
+=IFERROR(A2/B2, 0)                  (Catch any error)
+```
+
+## Documentation in Cells
+
+Use Excel comments (not cell notes) for formulas needing explanation:
+
+```
+Cell C7 (EBITDA calculation):
+Comment: "EBITDA = Revenue - COGS - OpEx. Based on full-year actuals from Finance system."
+
+Cell B5 (Gross Margin assumption):
+Comment: "Historical 40% based on 3-year average. See Data!B:B for backup calculations."
+```
+
+## Common Financial Model Patterns
+
+### Scenario Analysis
+
+Create separate sections or sheets for Base, Bull, Bear cases:
+
+```
+                   [Base]     [Bull]     [Bear]
+Revenue Growth     40%        60%        20%       <- Blue inputs
+EBITDA Margin      35%        40%        30%       <- Blue inputs
+[All metrics below use formulas referencing above]
+```
+
+### Waterfall from Revenue to Free Cash Flow
+
+```
+Revenue                                    <- Input or formula from sales forecast
+- COGS                                     <- Input or % of revenue
+= Gross Profit                             <- Formula
+- Operating Expenses                       <- Input or calculated
+= EBITDA                                   <- Formula
+- D&A                                      <- Input or calculated
+= EBIT                                     <- Formula
+- Interest                                 <- Input or calculated
+- Taxes                                    <- Formula (EBIT * tax rate)
+= Net Income                               <- Formula
++ D&A (add back)                          <- Formula
+- Capex                                    <- Input
+- Working Capital Change                   <- Formula
+= Free Cash Flow                           <- Formula
+```
+
+## Checkpoints for Model Validation
+
+Before sharing a financial model:
+
+1. **Formula integrity**: Run recalc.py and verify zero errors
+2. **Color consistency**: All inputs blue, all formulas black, assumptions yellow
+3. **Documentation**: Complex formulas have comments, sources cited
+4. **Formatting**: Currency formatted, percentages 0.0%, years as text
+5. **Cross-checks**: Income statement ties to cash flow, balance sheet balances
+6. **Scenario testing**: Change an assumption, verify all dependents update
+7. **Reasonableness**: Review outputs for logic errors (negative revenue, etc.)
+
+## Example: Simple 3-Year Revenue Model
+
+```python
+from openpyxl import Workbook
+from openpyxl.styles import Font, PatternFill
+
+wb = Workbook()
+ws = wb.active
+ws.title = "P&L"
+
+# Headers
+ws['A1'] = "Metric"
+ws['B1'] = "2024A"
+ws['C1'] = "2025E"
+ws['D1'] = "2026E"
+
+# Revenue (Blue inputs for projections)
+ws['A2'] = "Revenue ($K)"
+ws['B2'] = 1000  # Actual
+ws['B2'].font = Font(color="000000")  # Black for actual
+ws['C2'].value = "=B2*(1+$B$5)"  # Formula
+ws['C2'].font = Font(color="000000")
+ws['D2'].value = "=C2*(1+$B$6)"
+ws['D2'].font = Font(color="000000")
+
+# Growth Rate (Blue inputs + Yellow assumption)
+ws['A5'] = "2025 Growth Rate"
+ws['B5'] = 0.50
+ws['B5'].font = Font(color="0000FF")
+ws['B5'].fill = PatternFill(start_color="FFFF00", fill_type="solid")
+ws['B5'].number_format = "0.0%"
+
+ws['A6'] = "2026 Growth Rate"
+ws['B6'] = 0.40
+ws['B6'].font = Font(color="0000FF")
+ws['B6'].fill = PatternFill(start_color="FFFF00", fill_type="solid")
+ws['B6'].number_format = "0.0%"
+
+# Format revenue cells
+for col in ['B', 'C', 'D']:
+    ws[f'{col}2'].number_format = "$#,##0"
+
+wb.save('p_and_l.xlsx')
+```
+
+Then run: `python scripts/recalc.py p_and_l.xlsx`

package/skills/xlsx/scripts/create_xlsx.py

@@ -1,53 +1,63 @@
 #!/usr/bin/env python3
 """
 Pro Sheets — Spreadsheet Creation Engine
+Takes a JSON spec and produces a professionally formatted .xlsx file.
+
+Usage: python create_xlsx.py spec.json output.xlsx
+
+JSON spec format: see references/spec-format.md
 """
 
 import json
 import sys
+import os
+from datetime import datetime
 
 try:
     import openpyxl
-    from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+    from openpyxl.styles import Font, PatternFill, Alignment, Border, Side, numbers
     from openpyxl.utils import get_column_letter
 except ImportError:
     print("ERROR: openpyxl not installed. Run: pip install openpyxl --break-system-packages")
     sys.exit(1)
 
+
+# ═══════════════════════════════════════════
+# DEFAULT BRAND
+# ═══════════════════════════════════════════
 DEFAULT_BRAND = {
-    "primary": "1B3A5C",
-    "accent": "2E86AB",
-    "light_bg": "F8FAFC",
-    "text_dark": "2C3E50",
-    "text_light": "FFFFFF",
-    "border": "D5D8DC",
-    "positive": "27AE60",
-    "negative": "E74C3C",
-    "highlight": "FFF8E1",
+    "primary": "1B3A5C",      # Dark navy headers
+    "accent": "2E86AB",       # Teal accents
+    "light_bg": "F8FAFC",     # Alternating row
+    "text_dark": "2C3E50",    # Body text
+    "text_light": "FFFFFF",   # White on dark
+    "border": "D5D8DC",       # Light gray borders
+    "positive": "27AE60",     # Green for positive
+    "negative": "E74C3C",     # Red for negative
+    "highlight": "FFF8E1",    # Gold highlight
     "font": "Arial",
 }
 
+# ═══════════════════════════════════════════
+# STYLE HELPERS
+# ═══════════════════════════════════════════
 
 def hex_color(c):
-    return c.lstrip("#")
-
+    return c.lstrip('#')
 
 def make_border(color="D5D8DC"):
-    side = Side(style="thin", color=hex_color(color))
+    side = Side(style='thin', color=hex_color(color))
     return Border(left=side, right=side, top=side, bottom=side)
 
-
 def header_font(brand, size=11):
     return Font(bold=True, size=size, color=hex_color(brand["text_light"]), name=brand["font"])
 
-
 def header_fill(brand):
     return PatternFill("solid", fgColor=hex_color(brand["primary"]))
 
-
 def body_font(brand, size=11, bold=False, color=None):
-    return Font(size=size, name=brand["font"], bold=bold, color=hex_color(color or brand["text_dark"]))
-
+    return Font(size=size, name=brand["font"], bold=bold,
+                color=hex_color(color or brand["text_dark"]))
 
 def alt_fill(brand, row_idx):
     if row_idx % 2 == 0:
@@ -56,6 +66,8 @@ def alt_fill(brand, row_idx):
 
 
 class ProSheetBuilder:
+    """Builds professional spreadsheets from a JSON spec."""
+
     def __init__(self, spec):
         self.spec = spec
         self.brand = {**DEFAULT_BRAND, **(spec.get("brand", {}))}
@@ -74,6 +86,7 @@ class ProSheetBuilder:
                 ws.title = sheet_spec.get("name", "Sheet1")
             else:
                 ws = self.wb.create_sheet(sheet_spec.get("name", f"Sheet{si+1}"))
+
             self._build_sheet(ws, sheet_spec)
 
         self.wb.save(output_path)
@@ -81,6 +94,7 @@ class ProSheetBuilder:
 
     def _build_sheet(self, ws, sheet_spec):
         sheet_type = sheet_spec.get("type", "data")
+
         if sheet_type == "dashboard":
             self._build_dashboard(ws, sheet_spec)
         elif sheet_type == "financial":
@@ -88,34 +102,42 @@ class ProSheetBuilder:
         else:
             self._build_data_sheet(ws, sheet_spec)
 
+        # Freeze panes
         freeze = sheet_spec.get("freeze_panes")
         if freeze:
             ws.freeze_panes = freeze
+
+        # Auto-filter
         if sheet_spec.get("auto_filter", False) and ws.max_row > 1:
             ws.auto_filter.ref = f"A1:{get_column_letter(ws.max_column)}{ws.max_row}"
 
     def _build_data_sheet(self, ws, sheet_spec):
+        """Standard data table with headers and rows."""
         headers = sheet_spec.get("headers", [])
         rows = sheet_spec.get("rows", [])
         col_widths = sheet_spec.get("col_widths", [])
         title = sheet_spec.get("title")
         start_row = 1
 
+        # Title row
         if title:
             ws.cell(row=1, column=1, value=title).font = Font(
-                bold=True, size=16, color=hex_color(self.brand["text_dark"]), name=self.brand["font"]
+                bold=True, size=16, color=hex_color(self.brand["text_dark"]),
+                name=self.brand["font"]
             )
             ws.merge_cells(start_row=1, start_column=1, end_row=1, end_column=max(len(headers), 1))
             start_row = 3
 
+        # Headers
         if headers:
             for ci, h in enumerate(headers, 1):
                 cell = ws.cell(row=start_row, column=ci, value=h)
                 cell.font = header_font(self.brand)
                 cell.fill = header_fill(self.brand)
-                cell.alignment = Alignment(horizontal="center", wrap_text=True)
+                cell.alignment = Alignment(horizontal='center', wrap_text=True)
                 cell.border = self.border
 
+        # Data rows
         for ri, row_data in enumerate(rows):
             r = start_row + 1 + ri
             for ci, val in enumerate(row_data, 1):
@@ -123,99 +145,153 @@ class ProSheetBuilder:
                 cell.font = body_font(self.brand)
                 cell.fill = alt_fill(self.brand, ri)
                 cell.border = self.border
-                cell.alignment = Alignment(wrap_text=True, vertical="top")
+                cell.alignment = Alignment(wrap_text=True, vertical='top')
+
+                # Auto-detect numeric alignment
                 if isinstance(val, (int, float)):
-                    cell.alignment = Alignment(horizontal="right", vertical="top")
+                    cell.alignment = Alignment(horizontal='right', vertical='top')
                     if isinstance(val, float) and abs(val) < 1:
-                        cell.number_format = "0.0%"
+                        cell.number_format = '0.0%'
                     elif isinstance(val, float):
-                        cell.number_format = "#,##0.00"
+                        cell.number_format = '#,##0.00'
                     elif isinstance(val, int) and val > 999:
-                        cell.number_format = "#,##0"
+                        cell.number_format = '#,##0'
 
+        # Column widths
         if col_widths:
             for ci, w in enumerate(col_widths, 1):
                 ws.column_dimensions[get_column_letter(ci)].width = w
         else:
+            # Auto-size based on header length
             for ci, h in enumerate(headers, 1):
                 ws.column_dimensions[get_column_letter(ci)].width = max(len(str(h)) + 4, 12)
 
+        # Formulas
         for formula_spec in sheet_spec.get("formulas", []):
-            cell = ws[formula_spec["cell"]]
-            cell.value = formula_spec["formula"]
+            cell_ref = formula_spec["cell"]
+            formula = formula_spec["formula"]
+            cell = ws[cell_ref]
+            cell.value = formula
             if formula_spec.get("bold", False):
                 cell.font = body_font(self.brand, bold=True)
             cell.border = self.border
 
     def _build_dashboard(self, ws, sheet_spec):
+        """Dashboard with KPI cards and summary tables."""
         title = sheet_spec.get("title", "Dashboard")
         kpis = sheet_spec.get("kpis", [])
         sections = sheet_spec.get("sections", [])
 
+        # Title
         ws.cell(row=1, column=1, value=title).font = Font(
-            bold=True, size=18, color=hex_color(self.brand["text_dark"]), name=self.brand["font"]
+            bold=True, size=18, color=hex_color(self.brand["text_dark"]),
+            name=self.brand["font"]
         )
         ws.merge_cells(start_row=1, start_column=1, end_row=1, end_column=max(len(kpis) * 2, 6))
 
+        # KPI row
         if kpis:
             r = 3
             for ki, kpi in enumerate(kpis):
                 col = ki * 2 + 1
-                v = ws.cell(row=r, column=col, value=kpi.get("value", ""))
-                v.font = Font(bold=True, size=22, name=self.brand["font"], color=hex_color(self.brand["accent"]))
-                v.alignment = Alignment(horizontal="center")
+                # Value
+                val_cell = ws.cell(row=r, column=col, value=kpi.get("value", ""))
+                val_cell.font = Font(bold=True, size=22, name=self.brand["font"],
+                                     color=hex_color(self.brand["accent"]))
+                val_cell.alignment = Alignment(horizontal='center')
                 ws.merge_cells(start_row=r, start_column=col, end_row=r, end_column=col + 1)
 
-                l = ws.cell(row=r + 1, column=col, value=kpi.get("label", ""))
-                l.font = Font(size=9, color="7F8C8D", name=self.brand["font"])
-                l.alignment = Alignment(horizontal="center")
+                # Label
+                lbl_cell = ws.cell(row=r + 1, column=col, value=kpi.get("label", ""))
+                lbl_cell.font = Font(size=9, color="7F8C8D", name=self.brand["font"])
+                lbl_cell.alignment = Alignment(horizontal='center')
                 ws.merge_cells(start_row=r + 1, start_column=col, end_row=r + 1, end_column=col + 1)
 
+                # Change indicator
+                change = kpi.get("change", "")
+                if change:
+                    chg_cell = ws.cell(row=r + 2, column=col, value=change)
+                    is_positive = change.startswith("+") or change.startswith("↑")
+                    chg_cell.font = Font(size=9, name=self.brand["font"], bold=True,
+                                         color=hex_color(self.brand["positive"] if is_positive else self.brand["negative"]))
+                    chg_cell.alignment = Alignment(horizontal='center')
+                    ws.merge_cells(start_row=r + 2, start_column=col, end_row=r + 2, end_column=col + 1)
+
+                # KPI card border
                 for dr in range(3):
                     for dc in range(2):
-                        c = ws.cell(row=r + dr, column=col + dc)
-                        c.fill = PatternFill("solid", fgColor=hex_color(self.brand["highlight"]))
-                        c.border = self.border
+                        cell = ws.cell(row=r + dr, column=col + dc)
+                        cell.fill = PatternFill("solid", fgColor=hex_color(self.brand["highlight"]))
+                        cell.border = self.border
 
+                ws.column_dimensions[get_column_letter(col)].width = 14
+                ws.column_dimensions[get_column_letter(col + 1)].width = 14
+
+        # Sections (mini tables below KPIs)
         current_row = 8 if kpis else 3
         for section in sections:
             ws.cell(row=current_row, column=1, value=section.get("title", "")).font = Font(
-                bold=True, size=13, color=hex_color(self.brand["text_dark"]), name=self.brand["font"]
+                bold=True, size=13, color=hex_color(self.brand["text_dark"]),
+                name=self.brand["font"]
             )
             current_row += 1
+
             headers = section.get("headers", [])
             rows = section.get("rows", [])
             for ci, h in enumerate(headers, 1):
-                c = ws.cell(row=current_row, column=ci, value=h)
-                c.font = header_font(self.brand, size=10)
-                c.fill = header_fill(self.brand)
-                c.border = self.border
-                c.alignment = Alignment(horizontal="center")
+                cell = ws.cell(row=current_row, column=ci, value=h)
+                cell.font = header_font(self.brand, size=10)
+                cell.fill = header_fill(self.brand)
+                cell.border = self.border
+                cell.alignment = Alignment(horizontal='center')
+                ws.column_dimensions[get_column_letter(ci)].width = max(len(str(h)) + 4, 14)
+
             for ri, row_data in enumerate(rows):
                 r = current_row + 1 + ri
                 for ci, val in enumerate(row_data, 1):
-                    c = ws.cell(row=r, column=ci, value=val)
-                    c.font = body_font(self.brand, size=10)
-                    c.fill = alt_fill(self.brand, ri)
-                    c.border = self.border
+                    cell = ws.cell(row=r, column=ci, value=val)
+                    cell.font = body_font(self.brand, size=10)
+                    cell.fill = alt_fill(self.brand, ri)
+                    cell.border = self.border
+
             current_row += len(rows) + 3
 
     def _build_financial(self, ws, sheet_spec):
+        """Financial model with blue inputs, black formulas, yellow assumptions."""
         self._build_data_sheet(ws, sheet_spec)
-        for ref in sheet_spec.get("input_cells", []):
-            ws[ref].font = Font(size=11, name=self.brand["font"], color="0000FF")
-        for ref in sheet_spec.get("assumption_cells", []):
-            ws[ref].fill = PatternFill("solid", fgColor="FFFF00")
+
+        # Apply financial color coding
+        input_cells = sheet_spec.get("input_cells", [])
+        assumption_cells = sheet_spec.get("assumption_cells", [])
+
+        for ref in input_cells:
+            cell = ws[ref]
+            cell.font = Font(size=11, name=self.brand["font"], color="0000FF")
+
+        for ref in assumption_cells:
+            cell = ws[ref]
+            cell.fill = PatternFill("solid", fgColor="FFFF00")
 
 
 def main():
     if len(sys.argv) < 3:
         print("Usage: python create_xlsx.py spec.json output.xlsx")
         sys.exit(1)
-    with open(sys.argv[1], "r", encoding="utf-8") as f:
+
+    spec_path = sys.argv[1]
+    output_path = sys.argv[2]
+
+    with open(spec_path, 'r') as f:
         spec = json.load(f)
-    ProSheetBuilder(spec).build(sys.argv[2])
-    print(f"Spreadsheet created: {sys.argv[2]}")
+
+    builder = ProSheetBuilder(spec)
+    builder.build(output_path)
+    print(f"Spreadsheet created: {output_path}")
+    print(f"  Sheets: {len(spec.get('sheets', []))}")
+    for s in spec.get("sheets", []):
+        rows = len(s.get("rows", []))
+        kpis = len(s.get("kpis", []))
+        print(f"    {s.get('name', 'Sheet')}: {rows} rows" + (f", {kpis} KPIs" if kpis else ""))
 
 
 if __name__ == "__main__":