openclaw-node-harness 2.0.0

package/skills/excel/scripts/excel.py

@@ -0,0 +1,1120 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Excel CLI - Comprehensive Excel file manipulation.
+
+Read, write, edit, and format Excel files (.xlsx, .xls).
+
+Usage:
+    excel.py info <file>
+    excel.py read <file> [--sheet NAME] [--range A1:B10] [--format json|csv|markdown]
+    excel.py cell <file> <cell> [--sheet NAME]
+    excel.py create <file> [--sheets NAME,NAME2]
+    excel.py write <file> --data JSON [--sheet NAME] [--start A1]
+    excel.py from-csv <csv_file> <excel_file> [--sheet NAME]
+    excel.py from-json <json_file> <excel_file> [--sheet NAME]
+    excel.py edit <file> <cell> <value> [--sheet NAME] [--formula]
+    excel.py add-sheet <file> <name> [--position N]
+    excel.py rename-sheet <file> <old_name> <new_name>
+    excel.py delete-sheet <file> <name>
+    excel.py copy-sheet <file> <source> <new_name>
+    excel.py insert-rows <file> <row> [--count N] [--sheet NAME]
+    excel.py insert-cols <file> <col> [--count N] [--sheet NAME]
+    excel.py delete-rows <file> <row> [--count N] [--sheet NAME]
+    excel.py delete-cols <file> <col> [--count N] [--sheet NAME]
+    excel.py merge <file> <range> [--sheet NAME]
+    excel.py unmerge <file> <range> [--sheet NAME]
+    excel.py format <file> <range> [--sheet NAME] [options...]
+    excel.py resize <file> [--row N:HEIGHT] [--col A:WIDTH] [--sheet NAME]
+    excel.py freeze <file> <cell> [--sheet NAME]
+    excel.py find <file> <text> [--sheet NAME]
+    excel.py replace <file> <old> <new> [--sheet NAME]
+    excel.py to-csv <file> <output> [--sheet NAME]
+    excel.py to-json <file> <output> [--sheet NAME]
+    excel.py to-markdown <file> [--sheet NAME]
+"""
+
+import argparse
+import csv
+import json
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Any, Optional, Union
+
+try:
+    from openpyxl import Workbook, load_workbook
+    from openpyxl.utils import get_column_letter, column_index_from_string
+    from openpyxl.utils.cell import coordinate_from_string
+    from openpyxl.styles import Font, PatternFill, Border, Side, Alignment
+    from openpyxl.styles.colors import Color
+    OPENPYXL_AVAILABLE = True
+except ImportError:
+    OPENPYXL_AVAILABLE = False
+
+try:
+    import xlrd
+    XLRD_AVAILABLE = True
+except ImportError:
+    XLRD_AVAILABLE = False
+
+
+def require_openpyxl():
+    if not OPENPYXL_AVAILABLE:
+        print("Error: openpyxl required. Install with: pip install openpyxl", file=sys.stderr)
+        sys.exit(1)
+
+
+def ok(data: Any):
+    """Output success JSON."""
+    print(json.dumps({"success": True, **data}, indent=2, default=str))
+
+
+def fail(message: str, details: Any = None):
+    """Output error JSON."""
+    result = {"success": False, "error": message}
+    if details:
+        result["details"] = details
+    print(json.dumps(result, indent=2, default=str))
+    sys.exit(1)
+
+
+def parse_range(range_str: str) -> tuple:
+    """Parse A1:B10 into ((1,1), (10,2))."""
+    if ':' in range_str:
+        start, end = range_str.upper().split(':')
+    else:
+        start = end = range_str.upper()
+    
+    start_col, start_row = coordinate_from_string(start)
+    end_col, end_row = coordinate_from_string(end)
+    
+    return (
+        (start_row, column_index_from_string(start_col)),
+        (end_row, column_index_from_string(end_col))
+    )
+
+
+def cell_to_coords(cell: str) -> tuple:
+    """Convert A1 to (row, col) tuple."""
+    col_str, row = coordinate_from_string(cell.upper())
+    return (row, column_index_from_string(col_str))
+
+
+def coords_to_cell(row: int, col: int) -> str:
+    """Convert (row, col) to A1 notation."""
+    return f"{get_column_letter(col)}{row}"
+
+
+def get_sheet(wb, sheet_name: Optional[str] = None):
+    """Get worksheet by name or active sheet."""
+    if sheet_name:
+        if sheet_name not in wb.sheetnames:
+            fail(f"Sheet '{sheet_name}' not found", {"available": wb.sheetnames})
+        return wb[sheet_name]
+    return wb.active
+
+
+def read_sheet_data(ws, range_str: Optional[str] = None) -> list:
+    """Read sheet data as list of lists."""
+    if range_str:
+        (start_row, start_col), (end_row, end_col) = parse_range(range_str)
+        data = []
+        for row in range(start_row, end_row + 1):
+            row_data = []
+            for col in range(start_col, end_col + 1):
+                cell = ws.cell(row=row, column=col)
+                row_data.append(cell.value)
+            data.append(row_data)
+        return data
+    else:
+        data = []
+        for row in ws.iter_rows(values_only=True):
+            data.append(list(row))
+        return data
+
+
+def data_to_markdown(data: list, headers: bool = True) -> str:
+    """Convert data to markdown table."""
+    if not data:
+        return "*Empty*"
+    
+    # Calculate column widths
+    widths = []
+    for col_idx in range(len(data[0])):
+        max_width = 3
+        for row in data:
+            if col_idx < len(row):
+                val = str(row[col_idx]) if row[col_idx] is not None else ""
+                max_width = max(max_width, len(val))
+        widths.append(max_width)
+    
+    lines = []
+    for i, row in enumerate(data):
+        cells = []
+        for j, val in enumerate(row):
+            val_str = str(val) if val is not None else ""
+            cells.append(val_str.ljust(widths[j]))
+        lines.append("| " + " | ".join(cells) + " |")
+        
+        if i == 0 and headers:
+            sep = ["-" * w for w in widths]
+            lines.append("| " + " | ".join(sep) + " |")
+    
+    return "\n".join(lines)
+
+
+def parse_color(color_str: str) -> str:
+    """Parse color string to ARGB hex."""
+    color_str = color_str.upper().strip()
+    
+    # Named colors
+    colors = {
+        "RED": "FFFF0000",
+        "GREEN": "FF00FF00",
+        "BLUE": "FF0000FF",
+        "YELLOW": "FFFFFF00",
+        "WHITE": "FFFFFFFF",
+        "BLACK": "FF000000",
+        "GRAY": "FF808080",
+        "GREY": "FF808080",
+        "ORANGE": "FFFFA500",
+        "PURPLE": "FF800080",
+        "PINK": "FFFFC0CB",
+        "CYAN": "FF00FFFF",
+    }
+    
+    if color_str in colors:
+        return colors[color_str]
+    
+    # Hex color (with or without #)
+    if color_str.startswith("#"):
+        color_str = color_str[1:]
+    
+    if len(color_str) == 6:
+        return "FF" + color_str
+    elif len(color_str) == 8:
+        return color_str
+    
+    return "FF000000"  # Default black
+
+
+# ============================================================================
+# Commands
+# ============================================================================
+
+def cmd_info(args):
+    """Get workbook information."""
+    require_openpyxl()
+    
+    try:
+        wb = load_workbook(args.file, read_only=False, data_only=True)
+    except Exception as e:
+        fail(f"Failed to open file: {e}")
+    
+    sheets_info = []
+    for name in wb.sheetnames:
+        ws = wb[name]
+        sheets_info.append({
+            "name": name,
+            "dimensions": ws.dimensions or "A1",
+            "max_row": ws.max_row,
+            "max_column": ws.max_column,
+        })
+    
+    ok({
+        "file": args.file,
+        "sheets": sheets_info,
+        "sheet_count": len(wb.sheetnames),
+        "active_sheet": wb.active.title if wb.active else None,
+    })
+    wb.close()
+
+
+def cmd_read(args):
+    """Read sheet data."""
+    require_openpyxl()
+    
+    try:
+        wb = load_workbook(args.file, read_only=True, data_only=True)
+    except Exception as e:
+        fail(f"Failed to open file: {e}")
+    
+    ws = get_sheet(wb, args.sheet)
+    data = read_sheet_data(ws, args.range)
+    
+    if args.format == "csv":
+        import io
+        output = io.StringIO()
+        writer = csv.writer(output)
+        for row in data:
+            writer.writerow(row)
+        print(output.getvalue())
+    elif args.format == "markdown":
+        print(data_to_markdown(data))
+    else:  # json
+        ok({
+            "sheet": ws.title,
+            "range": args.range or ws.dimensions,
+            "rows": len(data),
+            "columns": len(data[0]) if data else 0,
+            "data": data,
+        })
+    
+    wb.close()
+
+
+def cmd_cell(args):
+    """Read a specific cell."""
+    require_openpyxl()
+    
+    try:
+        wb = load_workbook(args.file, read_only=True, data_only=False)
+    except Exception as e:
+        fail(f"Failed to open file: {e}")
+    
+    ws = get_sheet(wb, args.sheet)
+    cell = ws[args.cell.upper()]
+    
+    ok({
+        "cell": args.cell.upper(),
+        "value": cell.value,
+        "formula": cell.value if isinstance(cell.value, str) and cell.value.startswith("=") else None,
+        "data_type": cell.data_type,
+        "is_merged": cell.coordinate in ws.merged_cells,
+    })
+    wb.close()
+
+
+def cmd_create(args):
+    """Create a new workbook."""
+    require_openpyxl()
+    
+    wb = Workbook()
+    
+    if args.sheets:
+        sheet_names = [s.strip() for s in args.sheets.split(",")]
+        # Rename first sheet
+        wb.active.title = sheet_names[0]
+        # Add additional sheets
+        for name in sheet_names[1:]:
+            wb.create_sheet(title=name)
+    
+    try:
+        wb.save(args.file)
+    except Exception as e:
+        fail(f"Failed to save file: {e}")
+    
+    ok({
+        "file": args.file,
+        "sheets": wb.sheetnames,
+        "created": True,
+    })
+
+
+def cmd_write(args):
+    """Write data to cells."""
+    require_openpyxl()
+    
+    # Load or create workbook
+    if os.path.exists(args.file):
+        wb = load_workbook(args.file)
+    else:
+        wb = Workbook()
+    
+    ws = get_sheet(wb, args.sheet)
+    
+    # Parse data
+    try:
+        data = json.loads(args.data)
+    except json.JSONDecodeError as e:
+        fail(f"Invalid JSON data: {e}")
+    
+    # Parse start cell
+    start_row, start_col = cell_to_coords(args.start)
+    
+    # Write data
+    if isinstance(data, list):
+        for i, row in enumerate(data):
+            if isinstance(row, list):
+                for j, val in enumerate(row):
+                    ws.cell(row=start_row + i, column=start_col + j, value=val)
+            else:
+                ws.cell(row=start_row + i, column=start_col, value=row)
+    elif isinstance(data, dict):
+        # Write as key-value pairs or headers + rows
+        if "headers" in data and "rows" in data:
+            for j, header in enumerate(data["headers"]):
+                ws.cell(row=start_row, column=start_col + j, value=header)
+            for i, row in enumerate(data["rows"]):
+                for j, val in enumerate(row):
+                    ws.cell(row=start_row + 1 + i, column=start_col + j, value=val)
+        else:
+            for i, (key, val) in enumerate(data.items()):
+                ws.cell(row=start_row + i, column=start_col, value=key)
+                ws.cell(row=start_row + i, column=start_col + 1, value=val)
+    else:
+        ws.cell(row=start_row, column=start_col, value=data)
+    
+    wb.save(args.file)
+    ok({
+        "file": args.file,
+        "sheet": ws.title,
+        "start": args.start,
+        "written": True,
+    })
+
+
+def cmd_from_csv(args):
+    """Create Excel from CSV."""
+    require_openpyxl()
+    
+    wb = Workbook()
+    ws = wb.active
+    if args.sheet:
+        ws.title = args.sheet
+    
+    try:
+        with open(args.csv_file, 'r', newline='', encoding='utf-8-sig') as f:
+            reader = csv.reader(f)
+            for row in reader:
+                ws.append(row)
+    except Exception as e:
+        fail(f"Failed to read CSV: {e}")
+    
+    wb.save(args.excel_file)
+    ok({
+        "source": args.csv_file,
+        "output": args.excel_file,
+        "sheet": ws.title,
+        "rows": ws.max_row,
+    })
+
+
+def cmd_from_json(args):
+    """Create Excel from JSON."""
+    require_openpyxl()
+    
+    try:
+        with open(args.json_file, 'r') as f:
+            data = json.load(f)
+    except Exception as e:
+        fail(f"Failed to read JSON: {e}")
+    
+    wb = Workbook()
+    ws = wb.active
+    if args.sheet:
+        ws.title = args.sheet
+    
+    if isinstance(data, list):
+        if data and isinstance(data[0], dict):
+            # List of dicts - use keys as headers
+            headers = list(data[0].keys())
+            ws.append(headers)
+            for item in data:
+                ws.append([item.get(h) for h in headers])
+        else:
+            # List of lists or values
+            for row in data:
+                if isinstance(row, list):
+                    ws.append(row)
+                else:
+                    ws.append([row])
+    elif isinstance(data, dict):
+        if "headers" in data and "rows" in data:
+            ws.append(data["headers"])
+            for row in data["rows"]:
+                ws.append(row)
+        else:
+            for key, val in data.items():
+                ws.append([key, val])
+    
+    wb.save(args.excel_file)
+    ok({
+        "source": args.json_file,
+        "output": args.excel_file,
+        "sheet": ws.title,
+        "rows": ws.max_row,
+    })
+
+
+def cmd_edit(args):
+    """Edit a cell value or formula."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    cell = ws[args.cell.upper()]
+    old_value = cell.value
+    
+    # Set new value
+    if args.formula:
+        if not args.value.startswith("="):
+            args.value = "=" + args.value
+        cell.value = args.value
+    else:
+        # Try to convert to appropriate type
+        try:
+            if args.value.lower() in ('true', 'false'):
+                cell.value = args.value.lower() == 'true'
+            elif '.' in args.value:
+                cell.value = float(args.value)
+            else:
+                cell.value = int(args.value)
+        except ValueError:
+            cell.value = args.value
+    
+    wb.save(args.file)
+    ok({
+        "cell": args.cell.upper(),
+        "old_value": old_value,
+        "new_value": cell.value,
+        "is_formula": args.formula,
+    })
+
+
+def cmd_add_sheet(args):
+    """Add a new sheet."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    
+    if args.name in wb.sheetnames:
+        fail(f"Sheet '{args.name}' already exists")
+    
+    if args.position is not None:
+        wb.create_sheet(title=args.name, index=args.position)
+    else:
+        wb.create_sheet(title=args.name)
+    
+    wb.save(args.file)
+    ok({
+        "added": args.name,
+        "sheets": wb.sheetnames,
+    })
+
+
+def cmd_rename_sheet(args):
+    """Rename a sheet."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    
+    if args.old_name not in wb.sheetnames:
+        fail(f"Sheet '{args.old_name}' not found")
+    
+    if args.new_name in wb.sheetnames:
+        fail(f"Sheet '{args.new_name}' already exists")
+    
+    wb[args.old_name].title = args.new_name
+    wb.save(args.file)
+    
+    ok({
+        "old_name": args.old_name,
+        "new_name": args.new_name,
+        "sheets": wb.sheetnames,
+    })
+
+
+def cmd_delete_sheet(args):
+    """Delete a sheet."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    
+    if args.name not in wb.sheetnames:
+        fail(f"Sheet '{args.name}' not found")
+    
+    if len(wb.sheetnames) == 1:
+        fail("Cannot delete the only sheet in workbook")
+    
+    del wb[args.name]
+    wb.save(args.file)
+    
+    ok({
+        "deleted": args.name,
+        "sheets": wb.sheetnames,
+    })
+
+
+def cmd_copy_sheet(args):
+    """Copy a sheet."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    
+    if args.source not in wb.sheetnames:
+        fail(f"Sheet '{args.source}' not found")
+    
+    if args.new_name in wb.sheetnames:
+        fail(f"Sheet '{args.new_name}' already exists")
+    
+    source_ws = wb[args.source]
+    new_ws = wb.copy_worksheet(source_ws)
+    new_ws.title = args.new_name
+    
+    wb.save(args.file)
+    ok({
+        "source": args.source,
+        "copy": args.new_name,
+        "sheets": wb.sheetnames,
+    })
+
+
+def cmd_insert_rows(args):
+    """Insert rows."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    ws.insert_rows(args.row, args.count)
+    wb.save(args.file)
+    
+    ok({
+        "inserted": "rows",
+        "at": args.row,
+        "count": args.count,
+        "sheet": ws.title,
+    })
+
+
+def cmd_insert_cols(args):
+    """Insert columns."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    # Convert column letter to number if needed
+    col = args.col
+    if isinstance(col, str) and col.isalpha():
+        col = column_index_from_string(col.upper())
+    
+    ws.insert_cols(int(col), args.count)
+    wb.save(args.file)
+    
+    ok({
+        "inserted": "columns",
+        "at": args.col,
+        "count": args.count,
+        "sheet": ws.title,
+    })
+
+
+def cmd_delete_rows(args):
+    """Delete rows."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    ws.delete_rows(args.row, args.count)
+    wb.save(args.file)
+    
+    ok({
+        "deleted": "rows",
+        "at": args.row,
+        "count": args.count,
+        "sheet": ws.title,
+    })
+
+
+def cmd_delete_cols(args):
+    """Delete columns."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    col = args.col
+    if isinstance(col, str) and col.isalpha():
+        col = column_index_from_string(col.upper())
+    
+    ws.delete_cols(int(col), args.count)
+    wb.save(args.file)
+    
+    ok({
+        "deleted": "columns",
+        "at": args.col,
+        "count": args.count,
+        "sheet": ws.title,
+    })
+
+
+def cmd_merge(args):
+    """Merge cells."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    ws.merge_cells(args.range)
+    wb.save(args.file)
+    
+    ok({
+        "merged": args.range,
+        "sheet": ws.title,
+    })
+
+
+def cmd_unmerge(args):
+    """Unmerge cells."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    ws.unmerge_cells(args.range)
+    wb.save(args.file)
+    
+    ok({
+        "unmerged": args.range,
+        "sheet": ws.title,
+    })
+
+
+def cmd_format(args):
+    """Format cells."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    (start_row, start_col), (end_row, end_col) = parse_range(args.range)
+    
+    applied = []
+    
+    for row in range(start_row, end_row + 1):
+        for col in range(start_col, end_col + 1):
+            cell = ws.cell(row=row, column=col)
+            
+            # Font
+            if args.bold is not None or args.italic is not None or args.font_size or args.font_color or args.font_name:
+                current_font = cell.font
+                cell.font = Font(
+                    name=args.font_name or current_font.name,
+                    size=args.font_size or current_font.size,
+                    bold=args.bold if args.bold is not None else current_font.bold,
+                    italic=args.italic if args.italic is not None else current_font.italic,
+                    color=parse_color(args.font_color) if args.font_color else current_font.color,
+                )
+                applied.append("font")
+            
+            # Fill/background
+            if args.bg_color:
+                cell.fill = PatternFill(start_color=parse_color(args.bg_color),
+                                         end_color=parse_color(args.bg_color),
+                                         fill_type="solid")
+                applied.append("background")
+            
+            # Alignment
+            if args.align or args.valign or args.wrap:
+                current_align = cell.alignment
+                cell.alignment = Alignment(
+                    horizontal=args.align or current_align.horizontal,
+                    vertical=args.valign or current_align.vertical,
+                    wrap_text=args.wrap if args.wrap is not None else current_align.wrap_text,
+                )
+                applied.append("alignment")
+            
+            # Border
+            if args.border:
+                side = Side(style=args.border, color="FF000000")
+                cell.border = Border(left=side, right=side, top=side, bottom=side)
+                applied.append("border")
+    
+    wb.save(args.file)
+    ok({
+        "range": args.range,
+        "sheet": ws.title,
+        "applied": list(set(applied)),
+    })
+
+
+def cmd_resize(args):
+    """Resize rows/columns."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    resized = []
+    
+    if args.row:
+        for spec in args.row:
+            row_num, height = spec.split(':')
+            ws.row_dimensions[int(row_num)].height = float(height)
+            resized.append(f"row {row_num} = {height}")
+    
+    if args.col:
+        for spec in args.col:
+            col_letter, width = spec.split(':')
+            ws.column_dimensions[col_letter.upper()].width = float(width)
+            resized.append(f"col {col_letter} = {width}")
+    
+    wb.save(args.file)
+    ok({
+        "sheet": ws.title,
+        "resized": resized,
+    })
+
+
+def cmd_freeze(args):
+    """Freeze panes at cell."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    ws.freeze_panes = args.cell.upper()
+    wb.save(args.file)
+    
+    ok({
+        "sheet": ws.title,
+        "frozen_at": args.cell.upper(),
+    })
+
+
+def cmd_find(args):
+    """Find text in sheet."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file, read_only=True, data_only=True)
+    ws = get_sheet(wb, args.sheet)
+    
+    results = []
+    search_lower = args.text.lower()
+    
+    for row in ws.iter_rows():
+        for cell in row:
+            if cell.value and search_lower in str(cell.value).lower():
+                results.append({
+                    "cell": cell.coordinate,
+                    "value": cell.value,
+                })
+    
+    ok({
+        "search": args.text,
+        "sheet": ws.title,
+        "found": len(results),
+        "results": results,
+    })
+    wb.close()
+
+
+def cmd_replace(args):
+    """Find and replace text."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file)
+    ws = get_sheet(wb, args.sheet)
+    
+    count = 0
+    
+    for row in ws.iter_rows():
+        for cell in row:
+            if cell.value and isinstance(cell.value, str) and args.old in cell.value:
+                cell.value = cell.value.replace(args.old, args.new)
+                count += 1
+    
+    wb.save(args.file)
+    ok({
+        "old": args.old,
+        "new": args.new,
+        "sheet": ws.title,
+        "replaced": count,
+    })
+
+
+def cmd_to_csv(args):
+    """Export sheet to CSV."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file, read_only=True, data_only=True)
+    ws = get_sheet(wb, args.sheet)
+    
+    with open(args.output, 'w', newline='', encoding='utf-8') as f:
+        writer = csv.writer(f)
+        for row in ws.iter_rows(values_only=True):
+            writer.writerow(row)
+    
+    ok({
+        "source": args.file,
+        "sheet": ws.title,
+        "output": args.output,
+        "rows": ws.max_row,
+    })
+    wb.close()
+
+
+def cmd_to_json(args):
+    """Export sheet to JSON."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file, read_only=True, data_only=True)
+    ws = get_sheet(wb, args.sheet)
+    
+    data = []
+    headers = None
+    
+    for i, row in enumerate(ws.iter_rows(values_only=True)):
+        if i == 0:
+            headers = list(row)
+        else:
+            row_dict = {}
+            for j, val in enumerate(row):
+                if j < len(headers) and headers[j]:
+                    row_dict[headers[j]] = val
+            data.append(row_dict)
+    
+    with open(args.output, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=2, default=str)
+    
+    ok({
+        "source": args.file,
+        "sheet": ws.title,
+        "output": args.output,
+        "rows": len(data),
+    })
+    wb.close()
+
+
+def cmd_to_markdown(args):
+    """Export sheet to markdown table."""
+    require_openpyxl()
+    
+    wb = load_workbook(args.file, read_only=True, data_only=True)
+    ws = get_sheet(wb, args.sheet)
+    
+    data = read_sheet_data(ws)
+    print(data_to_markdown(data))
+    wb.close()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Excel CLI - Read, write, edit, and format Excel files",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+    
+    # info
+    p = subparsers.add_parser("info", help="Get workbook information")
+    p.add_argument("file", help="Excel file path")
+    
+    # read
+    p = subparsers.add_parser("read", help="Read sheet data")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    p.add_argument("--range", "-r", help="Cell range (e.g., A1:D10)")
+    p.add_argument("--format", "-f", choices=["json", "csv", "markdown"], default="json")
+    
+    # cell
+    p = subparsers.add_parser("cell", help="Read a specific cell")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("cell", help="Cell reference (e.g., A1)")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # create
+    p = subparsers.add_parser("create", help="Create new workbook")
+    p.add_argument("file", help="Output file path")
+    p.add_argument("--sheets", help="Comma-separated sheet names")
+    
+    # write
+    p = subparsers.add_parser("write", help="Write data to cells")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("--data", "-d", required=True, help="JSON data to write")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    p.add_argument("--start", default="A1", help="Starting cell (default: A1)")
+    
+    # from-csv
+    p = subparsers.add_parser("from-csv", help="Create Excel from CSV")
+    p.add_argument("csv_file", help="Input CSV file")
+    p.add_argument("excel_file", help="Output Excel file")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # from-json
+    p = subparsers.add_parser("from-json", help="Create Excel from JSON")
+    p.add_argument("json_file", help="Input JSON file")
+    p.add_argument("excel_file", help="Output Excel file")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # edit
+    p = subparsers.add_parser("edit", help="Edit a cell")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("cell", help="Cell reference")
+    p.add_argument("value", help="New value")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    p.add_argument("--formula", "-F", action="store_true", help="Value is a formula")
+    
+    # add-sheet
+    p = subparsers.add_parser("add-sheet", help="Add a new sheet")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("name", help="New sheet name")
+    p.add_argument("--position", "-p", type=int, help="Position index")
+    
+    # rename-sheet
+    p = subparsers.add_parser("rename-sheet", help="Rename a sheet")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("old_name", help="Current sheet name")
+    p.add_argument("new_name", help="New sheet name")
+    
+    # delete-sheet
+    p = subparsers.add_parser("delete-sheet", help="Delete a sheet")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("name", help="Sheet name to delete")
+    
+    # copy-sheet
+    p = subparsers.add_parser("copy-sheet", help="Copy a sheet")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("source", help="Source sheet name")
+    p.add_argument("new_name", help="New sheet name")
+    
+    # insert-rows
+    p = subparsers.add_parser("insert-rows", help="Insert rows")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("row", type=int, help="Row number to insert at")
+    p.add_argument("--count", "-n", type=int, default=1, help="Number of rows")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # insert-cols
+    p = subparsers.add_parser("insert-cols", help="Insert columns")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("col", help="Column (letter or number) to insert at")
+    p.add_argument("--count", "-n", type=int, default=1, help="Number of columns")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # delete-rows
+    p = subparsers.add_parser("delete-rows", help="Delete rows")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("row", type=int, help="Starting row number")
+    p.add_argument("--count", "-n", type=int, default=1, help="Number of rows")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # delete-cols
+    p = subparsers.add_parser("delete-cols", help="Delete columns")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("col", help="Column (letter or number)")
+    p.add_argument("--count", "-n", type=int, default=1, help="Number of columns")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # merge
+    p = subparsers.add_parser("merge", help="Merge cells")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("range", help="Cell range to merge (e.g., A1:C1)")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # unmerge
+    p = subparsers.add_parser("unmerge", help="Unmerge cells")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("range", help="Cell range to unmerge")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # format
+    p = subparsers.add_parser("format", help="Format cells")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("range", help="Cell range to format")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    p.add_argument("--bold", "-b", action="store_true", default=None)
+    p.add_argument("--no-bold", dest="bold", action="store_false")
+    p.add_argument("--italic", "-i", action="store_true", default=None)
+    p.add_argument("--no-italic", dest="italic", action="store_false")
+    p.add_argument("--font-size", type=int, help="Font size")
+    p.add_argument("--font-color", help="Font color (name or hex)")
+    p.add_argument("--font-name", help="Font name")
+    p.add_argument("--bg-color", help="Background color")
+    p.add_argument("--align", choices=["left", "center", "right"])
+    p.add_argument("--valign", choices=["top", "center", "bottom"])
+    p.add_argument("--wrap", action="store_true", default=None)
+    p.add_argument("--no-wrap", dest="wrap", action="store_false")
+    p.add_argument("--border", choices=["thin", "medium", "thick", "double"])
+    
+    # resize
+    p = subparsers.add_parser("resize", help="Resize rows/columns")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("--row", action="append", help="Row:height (e.g., 1:30)")
+    p.add_argument("--col", action="append", help="Col:width (e.g., A:20)")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # freeze
+    p = subparsers.add_parser("freeze", help="Freeze panes")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("cell", help="Cell to freeze at (e.g., A2 freezes row 1)")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # find
+    p = subparsers.add_parser("find", help="Find text in sheet")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("text", help="Text to search for")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # replace
+    p = subparsers.add_parser("replace", help="Find and replace text")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("old", help="Text to find")
+    p.add_argument("new", help="Replacement text")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # to-csv
+    p = subparsers.add_parser("to-csv", help="Export sheet to CSV")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("output", help="Output CSV file")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # to-json
+    p = subparsers.add_parser("to-json", help="Export sheet to JSON")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("output", help="Output JSON file")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    # to-markdown
+    p = subparsers.add_parser("to-markdown", help="Export sheet to markdown")
+    p.add_argument("file", help="Excel file path")
+    p.add_argument("--sheet", "-s", help="Sheet name")
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+    
+    commands = {
+        "info": cmd_info,
+        "read": cmd_read,
+        "cell": cmd_cell,
+        "create": cmd_create,
+        "write": cmd_write,
+        "from-csv": cmd_from_csv,
+        "from-json": cmd_from_json,
+        "edit": cmd_edit,
+        "add-sheet": cmd_add_sheet,
+        "rename-sheet": cmd_rename_sheet,
+        "delete-sheet": cmd_delete_sheet,
+        "copy-sheet": cmd_copy_sheet,
+        "insert-rows": cmd_insert_rows,
+        "insert-cols": cmd_insert_cols,
+        "delete-rows": cmd_delete_rows,
+        "delete-cols": cmd_delete_cols,
+        "merge": cmd_merge,
+        "unmerge": cmd_unmerge,
+        "format": cmd_format,
+        "resize": cmd_resize,
+        "freeze": cmd_freeze,
+        "find": cmd_find,
+        "replace": cmd_replace,
+        "to-csv": cmd_to_csv,
+        "to-json": cmd_to_json,
+        "to-markdown": cmd_to_markdown,
+    }
+    
+    try:
+        commands[args.command](args)
+    except Exception as e:
+        fail(str(e))
+
+
+if __name__ == "__main__":
+    main()