@heylemon/lemonade 0.1.6 → 0.1.7

package/skills/xlsx/scripts/recalc.py

@@ -1,183 +1,193 @@
+#!/usr/bin/env python3
 """
-Excel Formula Recalculation Script
-Recalculates all formulas in an Excel file using LibreOffice
+Recalculate formulas in Excel files using LibreOffice.
+
+Sets up a LibreOffice macro to recalculate all formulas and save the file.
+Scans for Excel error values and returns detailed diagnostics.
+
+Usage:
+    python recalc.py file.xlsx [timeout_seconds]
+
+Output:
+    JSON report with status, total errors, error locations, etc.
 """
 
 import json
+import sys
 import os
-import platform
 import subprocess
-import sys
+import tempfile
 from pathlib import Path
 
-from office.soffice import get_soffice_env
+try:
+    from openpyxl import load_workbook
+except ImportError:
+    print("ERROR: openpyxl not installed. Run: pip install openpyxl --break-system-packages")
+    sys.exit(1)
 
-from openpyxl import load_workbook
 
-MACRO_DIR_MACOS = "~/Library/Application Support/LibreOffice/4/user/basic/Standard"
-MACRO_DIR_LINUX = "~/.config/libreoffice/4/user/basic/Standard"
-MACRO_FILENAME = "Module1.xba"
+MACRO_CODE = '''
+Sub RecalculateAndSave()
+    ThisComponent.calculateAll()
+    ThisComponent.storeToURL(ThisComponent.getURL(), Array())
+End Sub
+'''
 
-RECALCULATE_MACRO = """<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">
-<script:module xmlns:script="http://openoffice.org/2000/script" script:name="Module1" script:language="StarBasic">
-    Sub RecalculateAndSave()
-      ThisComponent.calculateAll()
-      ThisComponent.store()
-      ThisComponent.close(True)
-    End Sub
-</script:module>"""
 
+def create_macro_file(macro_dir):
+    """Create LibreOffice macro for recalculation."""
+    macro_path = Path(macro_dir) / "Standard" / "Module1.xba"
+    macro_path.parent.mkdir(parents=True, exist_ok=True)
 
-def has_gtimeout():
-    try:
-        subprocess.run(
-            ["gtimeout", "--version"], capture_output=True, timeout=1, check=False
-        )
-        return True
-    except (FileNotFoundError, subprocess.TimeoutExpired):
-        return False
-
-
-def setup_libreoffice_macro():
-    macro_dir = os.path.expanduser(
-        MACRO_DIR_MACOS if platform.system() == "Darwin" else MACRO_DIR_LINUX
-    )
-    macro_file = os.path.join(macro_dir, MACRO_FILENAME)
-
-    if (
-        os.path.exists(macro_file)
-        and "RecalculateAndSave" in Path(macro_file).read_text()
-    ):
-        return True
-
-    if not os.path.exists(macro_dir):
-        subprocess.run(
-            ["soffice", "--headless", "--terminate_after_init"],
-            capture_output=True,
-            timeout=10,
-            env=get_soffice_env(),
-        )
-        os.makedirs(macro_dir, exist_ok=True)
-
-    try:
-        Path(macro_file).write_text(RECALCULATE_MACRO)
-        return True
-    except Exception:
-        return False
-
-
-def recalc(filename, timeout=30):
-    if not Path(filename).exists():
-        return {"error": f"File {filename} does not exist"}
-
-    abs_path = str(Path(filename).absolute())
+    macro_content = '''<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE script:module PUBLIC "-//OpenOffice.org//DTD OfficeDocument 1.0//EN" "module.dtd">
+<script:module xmlns:script="http://openoffice.org/2000/script" script:name="Module1" script:language="Basic">
+<script:code>Sub RecalculateAndSave()
+    ThisComponent.calculateAll()
+    ThisComponent.storeToURL(ThisComponent.getURL(), Array())
+End Sub
+</script:code>
+</script:module>'''
 
-    if not setup_libreoffice_macro():
-        return {"error": "Failed to setup LibreOffice macro"}
+    with open(macro_path, 'w') as f:
+        f.write(macro_content)
 
-    cmd = [
-        "soffice",
-        "--headless",
-        "--norestore",
-        "vnd.sun.star.script:Standard.Module1.RecalculateAndSave?language=Basic&location=application",
-        abs_path,
-    ]
+    return str(macro_path)
 
-    if platform.system() == "Linux":
-        cmd = ["timeout", str(timeout)] + cmd
-    elif platform.system() == "Darwin" and has_gtimeout():
-        cmd = ["gtimeout", str(timeout)] + cmd
 
-    result = subprocess.run(cmd, capture_output=True, text=True, env=get_soffice_env())
+def recalculate_with_libreoffice(xlsx_path, timeout=30):
+    """Use LibreOffice to recalculate formulas."""
+    xlsx_abs = os.path.abspath(xlsx_path)
 
-    if result.returncode != 0 and result.returncode != 124:  
-        error_msg = result.stderr or "Unknown error during recalculation"
-        if "Module1" in error_msg or "RecalculateAndSave" not in error_msg:
-            return {"error": "LibreOffice macro not configured properly"}
-        return {"error": error_msg}
+    if not os.path.exists(xlsx_abs):
+        return {
+            "status": "error",
+            "message": f"File not found: {xlsx_abs}",
+            "file": xlsx_path
+        }
 
     try:
-        wb = load_workbook(filename, data_only=True)
-
-        excel_errors = [
-            "#VALUE!",
-            "#DIV/0!",
-            "#REF!",
-            "#NAME?",
-            "#NULL!",
-            "#NUM!",
-            "#N/A",
+        # Run LibreOffice headless to recalculate
+        cmd = [
+            'soffice',
+            '--headless',
+            '--invisible',
+            '--norestore',
+            '--calc',
+            '--macro', 'vnd.sun.star.script:Standard.Module1.RecalculateAndSave?language=Basic&location=application',
+            xlsx_abs
         ]
-        error_details = {err: [] for err in excel_errors}
-        total_errors = 0
-
-        for sheet_name in wb.sheetnames:
-            ws = wb[sheet_name]
-            for row in ws.iter_rows():
-                for cell in row:
-                    if cell.value is not None and isinstance(cell.value, str):
-                        for err in excel_errors:
-                            if err in cell.value:
-                                location = f"{sheet_name}!{cell.coordinate}"
-                                error_details[err].append(location)
-                                total_errors += 1
-                                break
-
-        wb.close()
-
-        result = {
-            "status": "success" if total_errors == 0 else "errors_found",
-            "total_errors": total_errors,
-            "error_summary": {},
+
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+
+        # LibreOffice exits 0 on success
+        if result.returncode != 0:
+            return {
+                "status": "warning",
+                "message": f"LibreOffice recalculation had non-zero exit: {result.returncode}",
+                "stderr": result.stderr[:500],
+                "file": xlsx_path
+            }
+
+    except subprocess.TimeoutExpired:
+        return {
+            "status": "error",
+            "message": f"LibreOffice recalculation timed out after {timeout}s",
+            "file": xlsx_path
+        }
+    except FileNotFoundError:
+        return {
+            "status": "warning",
+            "message": "soffice (LibreOffice) not found. Attempting to scan file without recalculation.",
+            "file": xlsx_path
         }
 
-        for err_type, locations in error_details.items():
-            if locations:
-                result["error_summary"][err_type] = {
-                    "count": len(locations),
-                    "locations": locations[:20],  
-                }
-
-        wb_formulas = load_workbook(filename, data_only=False)
-        formula_count = 0
-        for sheet_name in wb_formulas.sheetnames:
-            ws = wb_formulas[sheet_name]
-            for row in ws.iter_rows():
-                for cell in row:
-                    if (
-                        cell.value
-                        and isinstance(cell.value, str)
-                        and cell.value.startswith("=")
-                    ):
-                        formula_count += 1
-        wb_formulas.close()
-
-        result["total_formulas"] = formula_count
-
-        return result
 
+def scan_for_errors(xlsx_path):
+    """Scan spreadsheet for formula errors."""
+    try:
+        wb = load_workbook(xlsx_path, data_only=False)
     except Exception as e:
-        return {"error": str(e)}
+        return {
+            "status": "error",
+            "message": f"Failed to load workbook: {str(e)}",
+            "file": xlsx_path
+        }
+
+    error_types = ["#VALUE!", "#DIV/0!", "#REF!", "#NAME?", "#NULL!", "#NUM!", "#N/A"]
+    error_details = []
+    error_summary = {err: 0 for err in error_types}
+    total_formulas = 0
+
+    for sheet_name in wb.sheetnames:
+        ws = wb[sheet_name]
+
+        for row in ws.iter_rows():
+            for cell in row:
+                # Count formulas
+                if cell.value and isinstance(cell.value, str) and cell.value.startswith("="):
+                    total_formulas += 1
+
+                    # Check for error values (when data_only=True is applied separately)
+                    # For now, we rely on LibreOffice to have calculated these
+
+                # Check cell value itself (if it's an error string)
+                if cell.value and isinstance(cell.value, str):
+                    for err_type in error_types:
+                        if cell.value.strip() == err_type:
+                            error_summary[err_type] += 1
+                            error_details.append({
+                                "cell": cell.coordinate,
+                                "error": err_type,
+                                "sheet": sheet_name
+                            })
+                            break
+
+    total_errors = sum(error_summary.values())
+
+    # Filter out zero counts from summary
+    error_summary = {k: v for k, v in error_summary.items() if v > 0}
+
+    return {
+        "status": "errors_found" if total_errors > 0 else "success",
+        "total_errors": total_errors,
+        "total_formulas": total_formulas,
+        "error_summary": error_summary,
+        "error_details": error_details,
+        "file": xlsx_path
+    }
 
 
 def main():
     if len(sys.argv) < 2:
-        print("Usage: python recalc.py <excel_file> [timeout_seconds]")
-        print("\nRecalculates all formulas in an Excel file using LibreOffice")
-        print("\nReturns JSON with error details:")
-        print("  - status: 'success' or 'errors_found'")
-        print("  - total_errors: Total number of Excel errors found")
-        print("  - total_formulas: Number of formulas in the file")
-        print("  - error_summary: Breakdown by error type with locations")
-        print("    - #VALUE!, #DIV/0!, #REF!, #NAME?, #NULL!, #NUM!, #N/A")
+        print("Usage: python recalc.py file.xlsx [timeout_seconds]")
         sys.exit(1)
 
-    filename = sys.argv[1]
+    xlsx_path = sys.argv[1]
     timeout = int(sys.argv[2]) if len(sys.argv) > 2 else 30
 
-    result = recalc(filename, timeout)
-    print(json.dumps(result, indent=2))
+    # Step 1: Recalculate with LibreOffice
+    recalc_result = recalculate_with_libreoffice(xlsx_path, timeout)
+
+    # If there was an error in recalculation, return it
+    if recalc_result.get("status") == "error":
+        print(json.dumps(recalc_result, indent=2))
+        sys.exit(1)
+
+    # Step 2: Scan for errors
+    scan_result = scan_for_errors(xlsx_path)
+
+    # Merge warning from recalculation if present
+    if recalc_result.get("status") == "warning":
+        if "warnings" not in scan_result:
+            scan_result["warnings"] = []
+        scan_result["warnings"].append(recalc_result["message"])
+
+    print(json.dumps(scan_result, indent=2))
+
+    # Exit with non-zero if errors found
+    if scan_result.get("total_errors", 0) > 0:
+        sys.exit(1)
 
 
 if __name__ == "__main__":

package/skills/xlsx/scripts/validate_xlsx.py

@@ -1,11 +1,14 @@
 #!/usr/bin/env python3
 """
-Validate an .xlsx file for formula errors.
+Validate an .xlsx file for formula errors and formatting issues.
+
+Usage: python validate_xlsx.py spreadsheet.xlsx
+Returns JSON with error details.
 """
 
 import json
-import os
 import sys
+import os
 
 try:
     from openpyxl import load_workbook
@@ -17,10 +20,11 @@ except ImportError:
 def validate(path):
     if not os.path.exists(path):
         print(json.dumps({"status": "error", "message": f"File not found: {path}"}))
-        return 1
+        sys.exit(1)
 
     wb = load_workbook(path, data_only=False)
     wb_data = load_workbook(path, data_only=True)
+
     result = {
         "status": "success",
         "total_errors": 0,
@@ -39,16 +43,21 @@ def validate(path):
 
         for row in ws.iter_rows():
             for cell in row:
+                # Count formulas
                 if cell.value and isinstance(cell.value, str) and cell.value.startswith("="):
                     sheet_info["formulas"] += 1
                     result["total_formulas"] += 1
+
+                    # Check calculated value for errors
                     data_cell = ws_data[cell.coordinate]
                     if data_cell.value and isinstance(data_cell.value, str):
                         for err_type in error_types:
                             if err_type in str(data_cell.value):
-                                sheet_info["errors"].append(
-                                    {"cell": cell.coordinate, "formula": cell.value, "error": err_type}
-                                )
+                                sheet_info["errors"].append({
+                                    "cell": cell.coordinate,
+                                    "formula": cell.value,
+                                    "error": err_type,
+                                })
                                 result["total_errors"] += 1
                                 if err_type not in result["error_summary"]:
                                     result["error_summary"][err_type] = {"count": 0, "locations": []}
@@ -57,6 +66,22 @@ def validate(path):
                                     f"{sheet_name}!{cell.coordinate}"
                                 )
 
+        # Warnings
+        if ws.max_row and ws.max_row > 10 and sheet_info["formulas"] == 0:
+            result["warnings"].append(
+                f"Sheet '{sheet_name}' has {ws.max_row} rows but no formulas — consider adding totals/summaries"
+            )
+
+        fonts_used = set()
+        for row in ws.iter_rows(max_row=min(ws.max_row or 1, 50)):
+            for cell in row:
+                if cell.font and cell.font.name:
+                    fonts_used.add(cell.font.name)
+        if len(fonts_used) > 3:
+            result["warnings"].append(
+                f"Sheet '{sheet_name}' uses {len(fonts_used)} fonts: {', '.join(sorted(fonts_used))}"
+            )
+
         result["sheets"][sheet_name] = sheet_info
 
     if result["total_errors"] > 0: