@nguyenphp/antigravity-marketing 1.0.16 → 1.0.19

package/templates/.agent/skills/minimax-xlsx/scripts/xlsx_add_column.py

@@ -0,0 +1,395 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+"""
+xlsx_add_column.py — Add a new column to a worksheet in an unpacked xlsx.
+
+Usage examples:
+    # Add a percentage column with formulas and number format
+    python3 xlsx_add_column.py /tmp/work/ --col G \\
+        --sheet "Budget FY2025" \\
+        --header "% of Total" \\
+        --formula '=F{row}/$F$10' --formula-rows 2:9 \\
+        --total-row 10 --total-formula '=SUM(G2:G9)' \\
+        --numfmt '0.0%'
+
+What it does:
+  1. Adds header cell (copies style from previous column's header)
+  2. Adds formula cells for the specified row range
+  3. Adds a total formula cell if specified
+  4. Creates a new cell style with the given numfmt if needed
+  5. Updates sharedStrings.xml for header text
+  6. Updates dimension ref and column definitions
+
+IMPORTANT: Run on an UNPACKED directory (from xlsx_unpack.py).
+After running, repack with xlsx_pack.py.
+"""
+
+import argparse
+import copy
+import os
+import re
+import sys
+import xml.dom.minidom
+import xml.etree.ElementTree as ET
+
+NS_SS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+NS_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+
+ET.register_namespace('', NS_SS)
+ET.register_namespace('r', NS_REL)
+ET.register_namespace('xdr', 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing')
+ET.register_namespace('x14', 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main')
+ET.register_namespace('xr2', 'http://schemas.microsoft.com/office/spreadsheetml/2015/revision2')
+ET.register_namespace('mc', 'http://schemas.openxmlformats.org/markup-compatibility/2006')
+
+
+def _tag(local: str) -> str:
+    return f"{{{NS_SS}}}{local}"
+
+
+def _write_tree(tree: ET.ElementTree, path: str) -> None:
+    tree.write(path, encoding="unicode", xml_declaration=False)
+    with open(path, "r", encoding="utf-8") as fh:
+        raw = fh.read()
+    try:
+        dom = xml.dom.minidom.parseString(raw.encode("utf-8"))
+        pretty = dom.toprettyxml(indent="  ", encoding="utf-8").decode("utf-8")
+        lines = [line for line in pretty.splitlines() if line.strip()]
+        with open(path, "w", encoding="utf-8") as fh:
+            fh.write("\n".join(lines) + "\n")
+    except Exception:
+        pass
+
+
+def col_number(s: str) -> int:
+    n = 0
+    for c in s.upper():
+        n = n * 26 + (ord(c) - 64)
+    return n
+
+
+def col_letter(n: int) -> str:
+    r = ""
+    while n > 0:
+        n, rem = divmod(n - 1, 26)
+        r = chr(65 + rem) + r
+    return r
+
+
+def find_ws_path(work_dir: str, sheet_name: str | None) -> str:
+    wb_tree = ET.parse(os.path.join(work_dir, "xl", "workbook.xml"))
+    rid = None
+    for sheet in wb_tree.getroot().iter(_tag("sheet")):
+        if sheet_name is None or sheet.get("name") == sheet_name:
+            rid = sheet.get(f"{{{NS_REL}}}id")
+            break
+
+    if rid is None:
+        print(f"ERROR: Sheet not found: {sheet_name}")
+        sys.exit(1)
+
+    rels_tree = ET.parse(os.path.join(work_dir, "xl", "_rels", "workbook.xml.rels"))
+    for rel in rels_tree.getroot():
+        if rel.get("Id") == rid:
+            return os.path.join(work_dir, "xl", rel.get("Target"))
+
+    print(f"ERROR: Relationship not found: {rid}")
+    sys.exit(1)
+
+
+def add_shared_string(work_dir: str, text: str) -> int:
+    ss_path = os.path.join(work_dir, "xl", "sharedStrings.xml")
+    tree = ET.parse(ss_path)
+    root = tree.getroot()
+
+    idx = 0
+    for si in root.findall(_tag("si")):
+        t_el = si.find(_tag("t"))
+        if t_el is not None and t_el.text == text:
+            return idx
+        idx += 1
+
+    si = ET.SubElement(root, _tag("si"))
+    t = ET.SubElement(si, _tag("t"))
+    t.set("{http://www.w3.org/XML/1998/namespace}space", "preserve")
+    t.text = text
+
+    root.set("count", str(int(root.get("count", "0")) + 1))
+    root.set("uniqueCount", str(int(root.get("uniqueCount", "0")) + 1))
+
+    _write_tree(tree, ss_path)
+    return idx
+
+
+def get_cell_style(ws_tree: ET.ElementTree, col: str, row: int) -> int:
+    ref = f"{col}{row}"
+    for row_el in ws_tree.getroot().iter(_tag("row")):
+        if row_el.get("r") == str(row):
+            for c in row_el:
+                if c.get("r") == ref:
+                    return int(c.get("s", "0"))
+    return 0
+
+
+def ensure_numfmt_style(work_dir: str, ref_style_idx: int, numfmt_code: str) -> int:
+    """Clone a cellXfs entry with the given numfmt. Returns new style index."""
+    styles_path = os.path.join(work_dir, "xl", "styles.xml")
+    tree = ET.parse(styles_path)
+    root = tree.getroot()
+
+    # Find or add numFmt
+    numfmts = root.find(_tag("numFmts"))
+    numfmt_id = None
+    if numfmts is not None:
+        for nf in numfmts:
+            if nf.get("formatCode") == numfmt_code:
+                numfmt_id = int(nf.get("numFmtId"))
+                break
+
+    if numfmt_id is None:
+        max_id = 163
+        if numfmts is not None:
+            for nf in numfmts:
+                max_id = max(max_id, int(nf.get("numFmtId", "0")))
+        else:
+            numfmts = ET.SubElement(root, _tag("numFmts"))
+            numfmts.set("count", "0")
+            root.remove(numfmts)
+            root.insert(0, numfmts)
+
+        numfmt_id = max_id + 1
+        nf = ET.SubElement(numfmts, _tag("numFmt"))
+        nf.set("numFmtId", str(numfmt_id))
+        nf.set("formatCode", numfmt_code)
+        numfmts.set("count", str(len(list(numfmts))))
+
+    # Find or create cellXfs entry
+    cellxfs = root.find(_tag("cellXfs"))
+    xf_list = list(cellxfs)
+    ref_xf = xf_list[min(ref_style_idx, len(xf_list) - 1)]
+
+    for i, xf in enumerate(xf_list):
+        if (xf.get("numFmtId") == str(numfmt_id) and
+                xf.get("fontId") == ref_xf.get("fontId") and
+                xf.get("fillId") == ref_xf.get("fillId") and
+                xf.get("borderId") == ref_xf.get("borderId")):
+            return i
+
+    new_xf = copy.deepcopy(ref_xf)
+    new_xf.set("numFmtId", str(numfmt_id))
+    new_xf.set("applyNumberFormat", "true")
+    cellxfs.append(new_xf)
+    cellxfs.set("count", str(len(list(cellxfs))))
+
+    _write_tree(tree, styles_path)
+    return len(list(cellxfs)) - 1
+
+
+def _apply_border_to_row(work_dir: str, ws_path: str, ws_tree: ET.ElementTree,
+                         ws_root: ET.Element, row_map: dict, border_row: int,
+                         border_style: str, new_col: str) -> None:
+    """Apply a top border to ALL cells in the specified row (A through new_col)."""
+    styles_path = os.path.join(work_dir, "xl", "styles.xml")
+    st_tree = ET.parse(styles_path)
+    st_root = st_tree.getroot()
+
+    # 1. Create a new border entry with the specified top style
+    borders = st_root.find(_tag("borders"))
+    new_border = ET.SubElement(borders, _tag("border"))
+    for side in ("left", "right"):
+        ET.SubElement(new_border, _tag(side))
+    top_el = ET.SubElement(new_border, _tag("top"))
+    top_el.set("style", border_style)
+    ET.SubElement(new_border, _tag("bottom"))
+    ET.SubElement(new_border, _tag("diagonal"))
+    borders.set("count", str(len(list(borders))))
+    new_border_id = len(list(borders)) - 1
+
+    # 2. For each existing style used in the row, create a clone with the new borderId
+    cellxfs = st_root.find(_tag("cellXfs"))
+    style_remap = {}  # old_style_idx -> new_style_idx
+
+    if border_row not in row_map:
+        return
+
+    row_el = row_map[border_row]
+    # Collect all cells in this row and their styles
+    for c in row_el:
+        old_s = int(c.get("s", "0"))
+        if old_s not in style_remap:
+            xf_list = list(cellxfs)
+            ref_xf = xf_list[min(old_s, len(xf_list) - 1)]
+            new_xf = copy.deepcopy(ref_xf)
+            new_xf.set("borderId", str(new_border_id))
+            new_xf.set("applyBorder", "true")
+            cellxfs.append(new_xf)
+            cellxfs.set("count", str(len(list(cellxfs))))
+            style_remap[old_s] = len(list(cellxfs)) - 1
+
+    # 3. Apply remapped styles to all cells in the row
+    for c in row_el:
+        old_s = int(c.get("s", "0"))
+        if old_s in style_remap:
+            c.set("s", str(style_remap[old_s]))
+
+    _write_tree(st_tree, styles_path)
+    last_col_num = col_number(new_col)
+    print(f"  Applied {border_style} top border to all cells in row {border_row} "
+          f"(A-{new_col}, {len(style_remap)} style(s) cloned)")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Add a column to a worksheet in an unpacked xlsx")
+    parser.add_argument("work_dir", help="Unpacked xlsx working directory")
+    parser.add_argument("--col", required=True, help="Column letter (e.g., G)")
+    parser.add_argument("--sheet", default=None, help="Sheet name (default: first)")
+    parser.add_argument("--header", default=None, help="Header text for row 1")
+    parser.add_argument("--formula", default=None,
+                        help="Formula template with {row} placeholder")
+    parser.add_argument("--formula-rows", default=None,
+                        help="Row range for formulas (e.g., 2:9)")
+    parser.add_argument("--total-row", type=int, default=None,
+                        help="Row number for total formula")
+    parser.add_argument("--total-formula", default=None,
+                        help="Formula for total row")
+    parser.add_argument("--numfmt", default=None,
+                        help="Number format for data/total cells (e.g., 0.0%%)")
+    parser.add_argument("--border-row", type=int, default=None,
+                        help="Row to apply a top border to ALL cells (e.g., 10)")
+    parser.add_argument("--border-style", default="medium",
+                        help="Border style: thin, medium, thick (default: medium)")
+    args = parser.parse_args()
+
+    col = args.col.upper()
+    prev_col = col_letter(col_number(col) - 1) if col_number(col) > 1 else "A"
+
+    ws_path = find_ws_path(args.work_dir, args.sheet)
+    ws_tree = ET.parse(ws_path)
+    changes = 0
+
+    print(f"Adding column {col} to {os.path.basename(ws_path)}")
+
+    # Resolve styles from previous column
+    header_style = get_cell_style(ws_tree, prev_col, 1) if args.header else 0
+
+    data_style = None
+    if args.formula_rows:
+        start_row = int(args.formula_rows.split(":")[0])
+        ref = get_cell_style(ws_tree, prev_col, start_row)
+        data_style = (ensure_numfmt_style(args.work_dir, ref, args.numfmt)
+                      if args.numfmt else ref)
+
+    total_style = None
+    if args.total_row:
+        ref = get_cell_style(ws_tree, prev_col, args.total_row)
+        total_style = (ensure_numfmt_style(args.work_dir, ref, args.numfmt)
+                       if args.numfmt else ref)
+
+    # Add header to sharedStrings
+    header_idx = add_shared_string(args.work_dir, args.header) if args.header else None
+
+    # Re-parse worksheet (sharedStrings write may have changed state)
+    ws_tree = ET.parse(ws_path)
+    root = ws_tree.getroot()
+    sheet_data = root.find(_tag("sheetData"))
+
+    row_map = {}
+    for row_el in sheet_data:
+        r = row_el.get("r")
+        if r:
+            row_map[int(r)] = row_el
+
+    # Add header cell
+    if args.header and 1 in row_map:
+        cell = ET.SubElement(row_map[1], _tag("c"))
+        cell.set("r", f"{col}1")
+        cell.set("s", str(header_style))
+        cell.set("t", "s")
+        v = ET.SubElement(cell, _tag("v"))
+        v.text = str(header_idx)
+        changes += 1
+        print(f"  {col}1 = \"{args.header}\" (header, style={header_style})")
+
+    # Add formula cells
+    if args.formula and args.formula_rows:
+        start, end = map(int, args.formula_rows.split(":"))
+        for row_num in range(start, end + 1):
+            if row_num not in row_map:
+                row_el = ET.SubElement(sheet_data, _tag("row"))
+                row_el.set("r", str(row_num))
+                row_map[row_num] = row_el
+
+            formula_text = args.formula.replace("{row}", str(row_num))
+            formula_text = formula_text.lstrip("=")
+            cell = ET.SubElement(row_map[row_num], _tag("c"))
+            cell.set("r", f"{col}{row_num}")
+            if data_style is not None:
+                cell.set("s", str(data_style))
+            f_el = ET.SubElement(cell, _tag("f"))
+            f_el.text = formula_text
+            changes += 1
+
+        print(f"  {col}{start}:{col}{end} = formulas (style={data_style})")
+
+    # Add total formula
+    if args.total_row and args.total_formula:
+        if args.total_row not in row_map:
+            row_el = ET.SubElement(sheet_data, _tag("row"))
+            row_el.set("r", str(args.total_row))
+            row_map[args.total_row] = row_el
+
+        total_f = args.total_formula.lstrip("=")
+        cell = ET.SubElement(row_map[args.total_row], _tag("c"))
+        cell.set("r", f"{col}{args.total_row}")
+        if total_style is not None:
+            cell.set("s", str(total_style))
+        f_el = ET.SubElement(cell, _tag("f"))
+        f_el.text = total_f
+        changes += 1
+        print(f"  {col}{args.total_row} = ={total_f} (style={total_style})")
+
+    # Update dimension
+    for dim in root.iter(_tag("dimension")):
+        old_ref = dim.get("ref", "")
+        if ":" in old_ref:
+            start_ref, end_ref = old_ref.split(":")
+            end_col_str = re.match(r"([A-Z]+)", end_ref).group(1)
+            end_row_str = re.search(r"(\d+)", end_ref).group(1)
+            if col_number(col) > col_number(end_col_str):
+                new_ref = f"{start_ref}:{col}{end_row_str}"
+                dim.set("ref", new_ref)
+                print(f"  Dimension: {old_ref} → {new_ref}")
+
+    # Extend <cols> to cover new column
+    cols_el = root.find(_tag("cols"))
+    if cols_el is not None:
+        new_col_num = col_number(col)
+        covered = any(
+            int(c.get("min", "0")) <= new_col_num <= int(c.get("max", "0"))
+            for c in cols_el
+        )
+        if not covered:
+            prev_num = col_number(prev_col)
+            for c in cols_el:
+                if int(c.get("min", "0")) <= prev_num <= int(c.get("max", "0")):
+                    new_col_def = copy.deepcopy(c)
+                    new_col_def.set("min", str(new_col_num))
+                    new_col_def.set("max", str(new_col_num))
+                    cols_el.append(new_col_def)
+                    print(f"  Added <col> definition for column {col}")
+                    break
+
+    # Apply border to entire row if requested
+    if args.border_row:
+        _apply_border_to_row(args.work_dir, ws_path, ws_tree, root,
+                             row_map, args.border_row, args.border_style,
+                             col)
+
+    _write_tree(ws_tree, ws_path)
+    print(f"\nDone. {changes} cells added.")
+    print(f"\nNext: python3 xlsx_pack.py {args.work_dir} output.xlsx")
+
+
+if __name__ == "__main__":
+    main()

package/templates/.agent/skills/minimax-xlsx/scripts/xlsx_insert_row.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+"""
+xlsx_insert_row.py — Insert a new data row into a worksheet in an unpacked xlsx.
+
+Usage examples:
+    # Insert "Utilities" row at position 6, copying styles from row 5
+    python3 xlsx_insert_row.py /tmp/work/ --at 6 \\
+        --sheet "Budget FY2025" \\
+        --text A=Utilities \\
+        --values B=3000 C=3000 D=3500 E=3500 \\
+        --formula 'F=SUM(B{row}:E{row})' \\
+        --copy-style-from 5
+
+What it does:
+  1. Shifts all rows >= at down by 1 (calls xlsx_shift_rows.py)
+  2. Adds text values to sharedStrings.xml
+  3. Inserts new row with specified cells (text, numbers, formulas)
+  4. Copies cell styles from a reference row
+  5. Updates dimension ref
+
+The shift operation automatically expands SUM formulas that span the
+insertion point, so total-row formulas are updated without extra work.
+
+IMPORTANT: Run on an UNPACKED directory (from xlsx_unpack.py).
+After running, repack with xlsx_pack.py.
+"""
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+import xml.dom.minidom
+import xml.etree.ElementTree as ET
+
+NS_SS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+NS_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+
+ET.register_namespace('', NS_SS)
+ET.register_namespace('r', NS_REL)
+ET.register_namespace('xdr', 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing')
+ET.register_namespace('x14', 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main')
+ET.register_namespace('xr2', 'http://schemas.microsoft.com/office/spreadsheetml/2015/revision2')
+ET.register_namespace('mc', 'http://schemas.openxmlformats.org/markup-compatibility/2006')
+
+
+def _tag(local: str) -> str:
+    return f"{{{NS_SS}}}{local}"
+
+
+def _write_tree(tree: ET.ElementTree, path: str) -> None:
+    tree.write(path, encoding="unicode", xml_declaration=False)
+    with open(path, "r", encoding="utf-8") as fh:
+        raw = fh.read()
+    try:
+        dom = xml.dom.minidom.parseString(raw.encode("utf-8"))
+        pretty = dom.toprettyxml(indent="  ", encoding="utf-8").decode("utf-8")
+        lines = [line for line in pretty.splitlines() if line.strip()]
+        with open(path, "w", encoding="utf-8") as fh:
+            fh.write("\n".join(lines) + "\n")
+    except Exception:
+        pass
+
+
+def col_number(s: str) -> int:
+    n = 0
+    for c in s.upper():
+        n = n * 26 + (ord(c) - 64)
+    return n
+
+
+def find_ws_path(work_dir: str, sheet_name: str | None) -> str:
+    wb_tree = ET.parse(os.path.join(work_dir, "xl", "workbook.xml"))
+    rid = None
+    for sheet in wb_tree.getroot().iter(_tag("sheet")):
+        if sheet_name is None or sheet.get("name") == sheet_name:
+            rid = sheet.get(f"{{{NS_REL}}}id")
+            break
+
+    if rid is None:
+        print(f"ERROR: Sheet not found: {sheet_name}")
+        sys.exit(1)
+
+    rels_tree = ET.parse(os.path.join(work_dir, "xl", "_rels", "workbook.xml.rels"))
+    for rel in rels_tree.getroot():
+        if rel.get("Id") == rid:
+            return os.path.join(work_dir, "xl", rel.get("Target"))
+
+    print(f"ERROR: Relationship not found: {rid}")
+    sys.exit(1)
+
+
+def add_shared_string(work_dir: str, text: str) -> int:
+    ss_path = os.path.join(work_dir, "xl", "sharedStrings.xml")
+    tree = ET.parse(ss_path)
+    root = tree.getroot()
+
+    idx = 0
+    for si in root.findall(_tag("si")):
+        t_el = si.find(_tag("t"))
+        if t_el is not None and t_el.text == text:
+            return idx
+        idx += 1
+
+    si = ET.SubElement(root, _tag("si"))
+    t = ET.SubElement(si, _tag("t"))
+    t.set("{http://www.w3.org/XML/1998/namespace}space", "preserve")
+    t.text = text
+
+    root.set("count", str(int(root.get("count", "0")) + 1))
+    root.set("uniqueCount", str(int(root.get("uniqueCount", "0")) + 1))
+
+    _write_tree(tree, ss_path)
+    return idx
+
+
+def get_row_styles(ws_tree: ET.ElementTree, row_num: int) -> dict[str, int]:
+    """Get {col_letter: style_index} for all cells in a row."""
+    styles = {}
+    for row_el in ws_tree.getroot().iter(_tag("row")):
+        if row_el.get("r") == str(row_num):
+            for c in row_el:
+                ref = c.get("r", "")
+                col_str = re.match(r"([A-Z]+)", ref)
+                if col_str:
+                    styles[col_str.group(1)] = int(c.get("s", "0"))
+            break
+    return styles
+
+
+def parse_kv(specs: list[str] | None) -> dict[str, str]:
+    if not specs:
+        return {}
+    result = {}
+    for spec in specs:
+        col, _, val = spec.partition("=")
+        result[col.upper()] = val
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Insert a new row into a worksheet in an unpacked xlsx")
+    parser.add_argument("work_dir", help="Unpacked xlsx working directory")
+    parser.add_argument("--at", type=int, required=True,
+                        help="Row number to insert at (existing rows shift down)")
+    parser.add_argument("--sheet", default=None, help="Sheet name (default: first)")
+    parser.add_argument("--text", nargs="+", default=None,
+                        help="Text cells: COL=VALUE (e.g., A=Utilities)")
+    parser.add_argument("--values", nargs="+", default=None,
+                        help="Numeric cells: COL=VALUE (e.g., B=3000 C=3000)")
+    parser.add_argument("--formula", nargs="+", default=None,
+                        help="Formula cells: COL=FORMULA with {row} (e.g., F=SUM(B{row}:E{row}))")
+    parser.add_argument("--copy-style-from", type=int, default=None,
+                        help="Copy cell styles from this row number")
+    args = parser.parse_args()
+
+    at = args.at
+    text_cells = parse_kv(args.text)
+    num_cells = parse_kv(args.values)
+    formula_cells = parse_kv(args.formula)
+
+    # Step 1: Shift rows down using xlsx_shift_rows.py
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    shift_script = os.path.join(script_dir, "xlsx_shift_rows.py")
+
+    print(f"Step 1: Shifting rows >= {at} down by 1...")
+    result = subprocess.run(
+        [sys.executable, shift_script, args.work_dir, "insert", str(at), "1"],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        print(f"ERROR: shift_rows failed:\n{result.stderr}")
+        sys.exit(1)
+    print(result.stdout)
+
+    # Step 2: Resolve worksheet path and get reference styles
+    ws_path = find_ws_path(args.work_dir, args.sheet)
+    ws_tree = ET.parse(ws_path)
+
+    ref_styles = {}
+    if args.copy_style_from is not None:
+        ref_styles = get_row_styles(ws_tree, args.copy_style_from)
+        print(f"Step 2: Copied styles from row {args.copy_style_from}: {ref_styles}")
+
+    # Step 3: Add text values to sharedStrings
+    text_indices = {}
+    for col, text in text_cells.items():
+        text_indices[col] = add_shared_string(args.work_dir, text)
+        print(f"  Added shared string: \"{text}\" → index {text_indices[col]}")
+
+    # Step 4: Re-parse worksheet and build new row
+    ws_tree = ET.parse(ws_path)
+    root = ws_tree.getroot()
+    sheet_data = root.find(_tag("sheetData"))
+
+    new_row = ET.Element(_tag("row"))
+    new_row.set("r", str(at))
+
+    all_cols = sorted(
+        set(list(text_cells) + list(num_cells) + list(formula_cells)),
+        key=col_number,
+    )
+
+    for col in all_cols:
+        cell = ET.SubElement(new_row, _tag("c"))
+        cell.set("r", f"{col}{at}")
+
+        if col in ref_styles:
+            cell.set("s", str(ref_styles[col]))
+
+        if col in text_cells:
+            cell.set("t", "s")
+            v = ET.SubElement(cell, _tag("v"))
+            v.text = str(text_indices[col])
+        elif col in num_cells:
+            # Omit t attribute for numbers — "n" is the default per OOXML spec
+            v = ET.SubElement(cell, _tag("v"))
+            v.text = str(num_cells[col])
+        elif col in formula_cells:
+            formula_text = formula_cells[col].replace("{row}", str(at)).lstrip("=")
+            f_el = ET.SubElement(cell, _tag("f"))
+            f_el.text = formula_text
+            # Use formula style from reference if available; it may differ
+            # from the data style (e.g., black font vs blue font).
+            # Look for the formula column's style specifically.
+            if col in ref_styles:
+                cell.set("s", str(ref_styles[col]))
+
+    # Insert new row at the correct position in sheetData (sorted by row number)
+    insert_idx = 0
+    for i, row_el in enumerate(list(sheet_data)):
+        r = row_el.get("r")
+        if r and int(r) > at:
+            insert_idx = i
+            break
+        insert_idx = i + 1
+
+    sheet_data.insert(insert_idx, new_row)
+
+    print(f"\nStep 3: Inserted row {at} with {len(all_cols)} cells:")
+    for col in all_cols:
+        if col in text_cells:
+            print(f"  {col}{at} = \"{text_cells[col]}\" (text)")
+        elif col in num_cells:
+            print(f"  {col}{at} = {num_cells[col]} (number)")
+        elif col in formula_cells:
+            ftext = formula_cells[col].replace("{row}", str(at))
+            print(f"  {col}{at} = {ftext} (formula)")
+
+    # Step 5: Update dimension
+    for dim in root.iter(_tag("dimension")):
+        old_ref = dim.get("ref", "")
+        if ":" in old_ref:
+            start_ref, end_ref = old_ref.split(":")
+            end_row = int(re.search(r"(\d+)", end_ref).group(1))
+            end_col = re.match(r"([A-Z]+)", end_ref).group(1)
+            # Dimension was already shifted by shift_rows, just verify
+            max_col = max(col_number(end_col), max(col_number(c) for c in all_cols))
+            max_col_letter = end_col if col_number(end_col) >= max_col else col
+            new_ref = f"{start_ref}:{max_col_letter}{end_row}"
+            if new_ref != old_ref:
+                dim.set("ref", new_ref)
+                print(f"\n  Dimension: {old_ref} → {new_ref}")
+
+    _write_tree(ws_tree, ws_path)
+
+    print(f"\nDone. Row {at} inserted successfully.")
+    print(f"\nNext: python3 xlsx_pack.py {args.work_dir} output.xlsx")
+
+
+if __name__ == "__main__":
+    main()