@cteno/sdk-linux-x64 0.0.0-stage → 2.10.13

package/skills/xlsx/scripts/xlsx_read.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Read an .xlsx workbook: inventory, JSON/CSV dumps, formula listing.
+
+Modes (pick one):
+  --sheets     JSON inventory: sheet names, dimensions, row/col counts
+  --json       dump one sheet's rows as a JSON array of arrays
+  --csv        dump one sheet as CSV to stdout or --out
+  --formulas   JSON list of formula cells {"cell", "formula", "cached"}
+  --notes      JSON list of cell notes/comments across sheets
+  --names      JSON map of workbook defined names
+
+Options:
+  --sheet NAME     sheet to dump (default: active sheet)
+  --data-only      load cached formula RESULTS instead of formula strings.
+                   Caveat: openpyxl never computes formulas; cached values
+                   exist only if the file was last saved by Excel/LibreOffice.
+  --encoding ENC   encoding for --csv --out files (default utf-8)
+  --out PATH       write --csv output to a file instead of stdout
+
+Usage:
+  xlsx_read.py book.xlsx --sheets
+  xlsx_read.py book.xlsx --json --sheet Data
+  xlsx_read.py book.xlsx --csv --sheet Data --out data.csv
+  xlsx_read.py book.xlsx --formulas
+  xlsx_read.py book.xlsx --notes
+  xlsx_read.py book.xlsx --names
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+from datetime import date, datetime, time
+
+from openpyxl import load_workbook
+
+
+def jsonable(value):
+    if isinstance(value, (datetime, date, time)):
+        return value.isoformat()
+    return value
+
+
+def sheet_rows(ws):
+    return [[jsonable(c) for c in row] for row in ws.iter_rows(values_only=True)]
+
+
+def cmd_sheets(wb):
+    info = []
+    for ws in wb.worksheets:
+        info.append({
+            "name": ws.title,
+            "dimensions": ws.dimensions,
+            "max_row": ws.max_row,
+            "max_col": ws.max_column,
+            "merged": [str(r) for r in ws.merged_cells.ranges],
+            "charts": len(getattr(ws, "_charts", [])),
+            "freeze_panes": ws.freeze_panes,
+            "autofilter": ws.auto_filter.ref,
+            "tables": {t.displayName: t.ref for t in ws.tables.values()},
+            "protected": bool(ws.protection.sheet),
+        })
+    names = {name: dn.attr_text for name, dn in wb.defined_names.items()}
+    print(json.dumps({"sheets": info, "defined_names": names},
+                     ensure_ascii=False, indent=2))
+
+
+def cmd_notes(wb, sheet):
+    out = []
+    sheets = [sheet] if sheet else wb.sheetnames
+    for name in sheets:
+        for row in wb[name].iter_rows():
+            for cell in row:
+                if cell.comment is not None:
+                    out.append({"sheet": name, "cell": cell.coordinate,
+                                "text": cell.comment.text,
+                                "author": cell.comment.author})
+    print(json.dumps({"notes": out}, ensure_ascii=False, indent=2))
+
+
+def cmd_names(wb):
+    names = {name: dn.attr_text for name, dn in wb.defined_names.items()}
+    print(json.dumps({"defined_names": names}, ensure_ascii=False, indent=2))
+
+
+def cmd_formulas(path, sheet):
+    wb_f = load_workbook(path, data_only=False)
+    wb_v = load_workbook(path, data_only=True)
+    out = []
+    sheets = [sheet] if sheet else wb_f.sheetnames
+    for name in sheets:
+        ws_f, ws_v = wb_f[name], wb_v[name]
+        for row in ws_f.iter_rows():
+            for cell in row:
+                if isinstance(cell.value, str) and cell.value.startswith("="):
+                    out.append({
+                        "sheet": name,
+                        "cell": cell.coordinate,
+                        "formula": cell.value,
+                        "cached": jsonable(ws_v[cell.coordinate].value),
+                    })
+    print(json.dumps({"formulas": out}, ensure_ascii=False, indent=2))
+
+
+def main(argv=None):
+    # Text I/O is UTF-8 regardless of the locale (GBK on Chinese Windows).
+    for stream in (sys.stdin, sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8")
+        except Exception:
+            pass
+    ap = argparse.ArgumentParser(description="Read/inspect an .xlsx workbook.")
+    ap.add_argument("file", help="path to .xlsx file")
+    mode = ap.add_mutually_exclusive_group(required=True)
+    mode.add_argument("--sheets", action="store_true")
+    mode.add_argument("--json", action="store_true")
+    mode.add_argument("--csv", action="store_true")
+    mode.add_argument("--formulas", action="store_true")
+    mode.add_argument("--notes", action="store_true")
+    mode.add_argument("--names", action="store_true")
+    ap.add_argument("--sheet", help="sheet name (default: active)")
+    ap.add_argument("--data-only", action="store_true",
+                    help="return cached formula results (see module docstring)")
+    ap.add_argument("--encoding", default="utf-8")
+    ap.add_argument("--out", help="output file for --csv")
+    args = ap.parse_args(argv)
+
+    if args.formulas:
+        cmd_formulas(args.file, args.sheet)
+        return 0
+
+    wb = load_workbook(args.file, data_only=args.data_only)
+    if args.sheets:
+        cmd_sheets(wb)
+        return 0
+    if args.notes:
+        cmd_notes(wb, args.sheet)
+        return 0
+    if args.names:
+        cmd_names(wb)
+        return 0
+
+    ws = wb[args.sheet] if args.sheet else wb.active
+    rows = sheet_rows(ws)
+    if args.json:
+        print(json.dumps({"sheet": ws.title, "rows": rows}, ensure_ascii=False))
+    else:  # --csv
+        if args.out:
+            with open(args.out, "w", newline="", encoding=args.encoding) as fh:
+                csv.writer(fh).writerows(
+                    [["" if v is None else v for v in r] for r in rows])
+            print(json.dumps({"ok": True, "out": args.out, "rows": len(rows)}))
+        else:
+            w = csv.writer(sys.stdout)
+            for r in rows:
+                w.writerow(["" if v is None else v for v in r])
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as exc:
+        print(json.dumps({"ok": False, "error": str(exc)}), file=sys.stderr)
+        sys.exit(1)

package/skills/xlsx/scripts/xlsx_recalc.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Recalculate a workbook's formulas headlessly with LibreOffice.
+
+openpyxl never computes formulas. This script shells out to `soffice`
+(LibreOffice) to open the workbook, recalculate, and re-save it, so
+cached formula results become available to `xlsx_read.py --data-only`
+and `--formulas`.
+
+Behavior:
+  * soffice on PATH: converts the file to .xlsx in a temp dir (which
+    recalculates all formulas) and replaces the original (or writes
+    --out). Prints {"recalculated": true, ...} and exits 0.
+  * soffice absent: prints {"recalculated": false, "reason": ...} with
+    installation guidance and STILL exits 0 — callers can branch on the
+    JSON instead of the exit code.
+
+Note: LibreOffice recalculates .xlsx on load per its default
+calculation settings; conversion re-saves with fresh cached values.
+
+Usage:
+  xlsx_recalc.py book.xlsx
+  xlsx_recalc.py book.xlsx --out recalced.xlsx
+  xlsx_recalc.py book.xlsx --timeout 120
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+def count_cached(path):
+    """Number of formula cells with a cached value present."""
+    from openpyxl import load_workbook
+    wb_f = load_workbook(path, data_only=False)
+    wb_v = load_workbook(path, data_only=True)
+    formulas = cached = 0
+    for name in wb_f.sheetnames:
+        ws_f, ws_v = wb_f[name], wb_v[name]
+        for row in ws_f.iter_rows():
+            for cell in row:
+                if isinstance(cell.value, str) and cell.value.startswith("="):
+                    formulas += 1
+                    if ws_v[cell.coordinate].value is not None:
+                        cached += 1
+    return formulas, cached
+
+
+def main(argv=None):
+    # Text I/O is UTF-8 regardless of the locale (GBK on Chinese Windows).
+    for stream in (sys.stdin, sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8")
+        except Exception:
+            pass
+    ap = argparse.ArgumentParser(
+        description="Recalculate .xlsx formulas headlessly via LibreOffice.")
+    ap.add_argument("file", help="path to .xlsx file")
+    ap.add_argument("--out", help="output path (default: replace input)")
+    ap.add_argument("--timeout", type=int, default=180,
+                    help="seconds to wait for soffice (default 180)")
+    args = ap.parse_args(argv)
+
+    src = Path(args.file).resolve()
+    if not src.exists():
+        print(json.dumps({"ok": False, "error": f"no such file: {src}"}),
+              file=sys.stderr)
+        return 1
+
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+    from render import find_soffice  # also finds the macOS/Windows app bundle, not only PATH
+    soffice = find_soffice()
+    if not soffice:
+        print(json.dumps({
+            "ok": True, "recalculated": False,
+            "reason": "LibreOffice (soffice) not found on PATH",
+            "guidance": "Install LibreOffice (e.g. `apt install "
+                        "libreoffice-calc` or `brew install --cask "
+                        "libreoffice`), or open the file in Excel/"
+                        "LibreOffice once and re-save it.",
+        }, ensure_ascii=False))
+        return 0
+
+    with tempfile.TemporaryDirectory() as tmp:
+        proc = subprocess.run(
+            [soffice, "--headless", "--calc", "--convert-to", "xlsx:Calc "
+             "MS Excel 2007 XML", "--outdir", tmp, str(src)],
+            capture_output=True, text=True, encoding="utf-8",
+            timeout=args.timeout,
+            env={"HOME": tmp, "PATH": Path(soffice).parent.as_posix()
+                 + ":/usr/bin:/bin"}, check=False)
+        produced = Path(tmp) / (src.stem + ".xlsx")
+        if proc.returncode != 0 or not produced.exists():
+            print(json.dumps({"ok": False,
+                              "error": "soffice conversion failed",
+                              "stderr": proc.stderr.strip()[-500:]}),
+                  file=sys.stderr)
+            return 1
+        formulas, cached = count_cached(produced)
+        dest = Path(args.out).resolve() if args.out else src
+        shutil.copyfile(produced, dest)
+
+    print(json.dumps({
+        "ok": True, "recalculated": True, "output": str(dest),
+        "formula_cells": formulas, "with_cached_values": cached,
+    }, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as exc:
+        print(json.dumps({"ok": False, "error": str(exc)}), file=sys.stderr)
+        sys.exit(1)

package/skills/xlsx/scripts/xlsx_restructure.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+"""Reference-aware row/column insert and delete for .xlsx workbooks.
+
+Unlike plain openpyxl insert_rows/delete_cols (and xlsx_edit.py's thin
+wrappers), this script also rewrites everything that points at the moved
+cells:
+
+  * formula references in ALL sheets, including absolute refs ($B$2),
+    ranges (B2:B9), and cross-sheet refs ('My Sheet'!A1 / Data!$B$8).
+    References into a deleted region become #REF!.
+  * merged-cell ranges (shifted; expanded when they span the insertion
+    point; removed when fully deleted)
+  * autofilter range, freeze panes, data-validation ranges,
+    conditional-formatting applied ranges (sqref)
+  * native table (ListObject) refs on the edited sheet
+  * workbook-scope defined names that point at the edited sheet
+  * row heights / column widths
+
+It prints a JSON report of every rewrite it made and lists what it
+could NOT shift (chart anchors, images, conditional-format RULE
+formulas). Full rules and limits: references/restructuring.md.
+
+One structural operation per invocation:
+
+Usage:
+  xlsx_restructure.py book.xlsx --sheet Data --insert-rows 3:2
+  xlsx_restructure.py book.xlsx --sheet Data --delete-rows 5
+  xlsx_restructure.py book.xlsx --sheet Data --insert-cols B:1 --out new.xlsx
+  xlsx_restructure.py book.xlsx --sheet Data --delete-cols 4:2
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+
+from openpyxl import load_workbook
+from openpyxl.formatting.formatting import ConditionalFormattingList
+from openpyxl.utils import (column_index_from_string, get_column_letter,
+                            range_boundaries)
+
+# A1-style reference, optionally sheet-qualified, optionally a range.
+# Guards: not preceded by a word char/$/. (avoids ABC123 identifiers) and
+# not followed by a word char or "(" (avoids function names like LOG10().
+REF_RE = re.compile(
+    r"(?<![\w$.:])"
+    r"(?P<sheet>(?:'(?:[^']|'')+'|[A-Za-z_][A-Za-z0-9_.]*)!)?"
+    r"(?P<start>\$?[A-Za-z]{1,3}\$?[0-9]{1,7})"
+    r"(?::(?P<end>\$?[A-Za-z]{1,3}\$?[0-9]{1,7}))?"
+    r"(?![\w(])")
+STRING_RE = re.compile(r'"(?:[^"]|"")*"')
+COORD_RE = re.compile(r"^(\$?)([A-Za-z]{1,3})(\$?)([0-9]+)$")
+
+
+def shift_point(v, idx, n, delete):
+    """New 1-based index for a single row/col, or None if deleted."""
+    if delete:
+        if v < idx:
+            return v
+        if v >= idx + n:
+            return v - n
+        return None
+    return v + n if v >= idx else v
+
+
+def shift_span(a, b, idx, n, delete):
+    """New (start, end) for an inclusive span, or None if fully deleted."""
+    if delete:
+        na = a if a < idx else (a - n if a >= idx + n else idx)
+        nb = b if b < idx else (b - n if b >= idx + n else idx - 1)
+        return None if na > nb else (na, nb)
+    return (a + n if a >= idx else a, b + n if b >= idx else b)
+
+
+def shift_range(rng, axis, idx, n, delete):
+    """Shift an A1 range string (no sheet prefix). None = fully deleted."""
+    min_col, min_row, max_col, max_row = range_boundaries(rng)
+    if axis == "rows":
+        span = shift_span(min_row, max_row, idx, n, delete)
+        if span is None:
+            return None
+        min_row, max_row = span
+    else:
+        span = shift_span(min_col, max_col, idx, n, delete)
+        if span is None:
+            return None
+        min_col, max_col = span
+    start = f"{get_column_letter(min_col)}{min_row}"
+    end = f"{get_column_letter(max_col)}{max_row}"
+    return start if start == end and ":" not in rng else f"{start}:{end}"
+
+
+class RefRewriter:
+    """Rewrite A1 references in formula-like text for one shift op."""
+
+    def __init__(self, target_sheet, axis, idx, n, delete):
+        self.target = target_sheet.lower()
+        self.axis, self.idx, self.n, self.delete = axis, idx, n, delete
+
+    def _shift_coord(self, coord):
+        m = COORD_RE.match(coord)
+        col_abs, col, row_abs, row = m.groups()
+        ci, ri = column_index_from_string(col.upper()), int(row)
+        if self.axis == "rows":
+            ri = shift_point(ri, self.idx, self.n, self.delete)
+            if ri is None:
+                return None
+        else:
+            ci = shift_point(ci, self.idx, self.n, self.delete)
+            if ci is None:
+                return None
+        return f"{col_abs}{get_column_letter(ci)}{row_abs}{ri}"
+
+    def _shift_pair(self, start, end):
+        """Shift a range preserving $ flags; None = collapsed to #REF!."""
+        new_start = self._shift_coord(start)
+        new_end = self._shift_coord(end)
+        if new_start is None or new_end is None:
+            # spans may survive partial deletion: clamp via span math
+            s, e = COORD_RE.match(start), COORD_RE.match(end)
+            if self.axis == "rows":
+                span = shift_span(int(s.group(4)), int(e.group(4)),
+                                  self.idx, self.n, self.delete)
+                if span is None:
+                    return None
+                new_start = f"{s.group(1)}{s.group(2)}{s.group(3)}{span[0]}"
+                new_end = f"{e.group(1)}{e.group(2)}{e.group(3)}{span[1]}"
+            else:
+                span = shift_span(column_index_from_string(s.group(2).upper()),
+                                  column_index_from_string(e.group(2).upper()),
+                                  self.idx, self.n, self.delete)
+                if span is None:
+                    return None
+                new_start = (f"{s.group(1)}{get_column_letter(span[0])}"
+                             f"{s.group(3)}{s.group(4)}")
+                new_end = (f"{e.group(1)}{get_column_letter(span[1])}"
+                           f"{e.group(3)}{e.group(4)}")
+        return new_start, new_end
+
+    def _sub(self, match, home_sheet):
+        prefix = match.group("sheet") or ""
+        if prefix:
+            name = prefix[:-1]
+            if name.startswith("'"):
+                name = name[1:-1].replace("''", "'")
+            ref_sheet = name
+        else:
+            ref_sheet = home_sheet
+        if ref_sheet.lower() != self.target:
+            return match.group(0)
+        start, end = match.group("start"), match.group("end")
+        if end is None:
+            new = self._shift_coord(start)
+            return prefix + ("#REF!" if new is None else new)
+        pair = self._shift_pair(start, end)
+        return (prefix + "#REF!" if pair is None
+                else f"{prefix}{pair[0]}:{pair[1]}")
+
+    def rewrite(self, text, home_sheet):
+        """Rewrite refs outside quoted string literals. Returns new text."""
+        out, pos = [], 0
+        for lit in STRING_RE.finditer(text):
+            out.append(REF_RE.sub(lambda m: self._sub(m, home_sheet),
+                                  text[pos:lit.start()]))
+            out.append(lit.group(0))
+            pos = lit.end()
+        out.append(REF_RE.sub(lambda m: self._sub(m, home_sheet), text[pos:]))
+        return "".join(out)
+
+
+def shift_dimensions(dims, idx, n, delete, is_row):
+    """Rebuild a row/column dimensions map with shifted keys."""
+    items = list(dims.items())
+    saved = {}
+    for key, dim in items:
+        pos = key if is_row else column_index_from_string(key)
+        new = shift_point(pos, idx, n, delete)
+        if new is not None and new != pos:
+            saved[new if is_row else get_column_letter(new)] = dim
+            del dims[key]
+    for key, dim in saved.items():
+        if is_row:
+            dim.index = key
+        else:
+            dim.index = column_index_from_string(key)
+        dims[key] = dim
+    return len(saved)
+
+
+def main(argv=None):
+    # Text I/O is UTF-8 regardless of the locale (GBK on Chinese Windows).
+    for stream in (sys.stdin, sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8")
+        except Exception:
+            pass
+    ap = argparse.ArgumentParser(
+        description="Insert/delete rows or columns AND rewrite formula "
+                    "references, merges, filters, validations, tables, and "
+                    "defined names to match.",
+        epilog="Cannot shift: chart anchors, images, conditional-format "
+               "rule formulas. See references/restructuring.md.")
+    ap.add_argument("file", help="path to .xlsx file")
+    ap.add_argument("--sheet", help="target sheet (default: active)")
+    ap.add_argument("--out", help="output path (default: edit in place)")
+    op = ap.add_mutually_exclusive_group(required=True)
+    op.add_argument("--insert-rows", metavar="IDX[:N]")
+    op.add_argument("--delete-rows", metavar="IDX[:N]")
+    op.add_argument("--insert-cols", metavar="COL[:N]",
+                    help="COL is a letter (B) or 1-based number")
+    op.add_argument("--delete-cols", metavar="COL[:N]")
+    args = ap.parse_args(argv)
+
+    raw = (args.insert_rows or args.delete_rows
+           or args.insert_cols or args.delete_cols)
+    idx_s, _, n_s = raw.partition(":")
+    n = int(n_s) if n_s else 1
+    axis = "rows" if (args.insert_rows or args.delete_rows) else "cols"
+    delete = bool(args.delete_rows or args.delete_cols)
+    if axis == "cols" and idx_s.isalpha():
+        idx = column_index_from_string(idx_s.upper())
+    else:
+        idx = int(idx_s)
+
+    wb = load_workbook(args.file)
+    ws = wb[args.sheet] if args.sheet else wb.active
+    rewriter = RefRewriter(ws.title, axis, idx, n, delete)
+    report = {"ok": True, "sheet": ws.title, "axis": axis,
+              "op": "delete" if delete else "insert", "index": idx, "count": n,
+              "formulas": [], "merges": [], "tables": {}, "defined_names": {},
+              "validations": [], "conditional_formats": [],
+              "not_shifted": ["chart anchors", "images",
+                              "conditional-format rule formulas"]}
+
+    # 1. capture merge ranges (openpyxl does not move them), then unmerge
+    old_merges = [str(r) for r in list(ws.merged_cells.ranges)]
+    for rng in old_merges:
+        ws.unmerge_cells(rng)
+
+    # 2. structural move of cell values/styles/comments
+    getattr(ws, f"{report['op']}_{axis}")(idx, n)
+
+    # 3. formulas everywhere
+    for sheet in wb.worksheets:
+        for row in sheet.iter_rows():
+            for cell in row:
+                if isinstance(cell.value, str) and cell.value.startswith("="):
+                    new = rewriter.rewrite(cell.value, sheet.title)
+                    if new != cell.value:
+                        report["formulas"].append(
+                            {"sheet": sheet.title, "cell": cell.coordinate,
+                             "from": cell.value, "to": new})
+                        cell.value = new
+
+    # 4. merges back, shifted
+    for rng in old_merges:
+        new = shift_range(rng, axis, idx, n, delete)
+        if new is None:
+            report["merges"].append({"from": rng, "to": None})
+        else:
+            ws.merge_cells(new)
+            if new != rng:
+                report["merges"].append({"from": rng, "to": new})
+
+    # 5. autofilter + freeze panes
+    if ws.auto_filter.ref:
+        new = shift_range(ws.auto_filter.ref, axis, idx, n, delete)
+        if new != ws.auto_filter.ref:
+            report["autofilter"] = {"from": ws.auto_filter.ref, "to": new}
+            ws.auto_filter.ref = new
+    if ws.freeze_panes:
+        m = COORD_RE.match(ws.freeze_panes)
+        ci = column_index_from_string(m.group(2).upper())
+        ri = int(m.group(4))
+        if axis == "rows":
+            ri = shift_point(ri, idx, n, delete) or max(idx, 2)
+        else:
+            ci = shift_point(ci, idx, n, delete) or max(idx, 2)
+        new = f"{get_column_letter(ci)}{ri}"
+        if new != ws.freeze_panes:
+            report["freeze_panes"] = {"from": ws.freeze_panes, "to": new}
+            ws.freeze_panes = new
+
+    # 6. data validations + conditional formatting applied ranges
+    for dv in ws.data_validations.dataValidation:
+        old = str(dv.sqref)
+        parts = [shift_range(p, axis, idx, n, delete) for p in old.split()]
+        parts = [p for p in parts if p]
+        if parts and " ".join(parts) != old:
+            dv.sqref = " ".join(parts)
+            report["validations"].append({"from": old, "to": str(dv.sqref)})
+    new_cf = ConditionalFormattingList()
+    for cf in ws.conditional_formatting:
+        old = str(cf.sqref)
+        parts = [shift_range(p, axis, idx, n, delete) for p in old.split()]
+        parts = [p for p in parts if p]
+        if not parts:
+            report["conditional_formats"].append({"from": old, "to": None})
+            continue
+        new = " ".join(parts)
+        for rule in cf.rules:
+            new_cf.add(new, rule)
+        if new != old:
+            report["conditional_formats"].append({"from": old, "to": new})
+    ws.conditional_formatting = new_cf
+
+    # 7. native tables on the edited sheet
+    for table in ws.tables.values():
+        new = shift_range(table.ref, axis, idx, n, delete)
+        if new and new != table.ref:
+            report["tables"][table.displayName] = {"from": table.ref,
+                                                   "to": new}
+            table.ref = new
+
+    # 8. workbook-scope defined names
+    for name, dn in wb.defined_names.items():
+        if dn.attr_text and "!" in dn.attr_text:
+            new = rewriter.rewrite(dn.attr_text, ws.title)
+            if new != dn.attr_text:
+                report["defined_names"][name] = {"from": dn.attr_text,
+                                                 "to": new}
+                dn.attr_text = new
+
+    # 9. row heights / column widths
+    if axis == "rows":
+        shift_dimensions(ws.row_dimensions, idx, n, delete, is_row=True)
+    else:
+        shift_dimensions(ws.column_dimensions, idx, n, delete, is_row=False)
+
+    out = args.out or args.file
+    wb.save(out)
+    report["output"] = out
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as exc:
+        print(json.dumps({"ok": False, "error": str(exc)}), file=sys.stderr)
+        sys.exit(1)