Xlsx

© 2025 Anthropic, PBC. All rights reserved.

LICENSE: Use of these materials (including all code, prompts, assets, files,
and other components of this Skill) is governed by your agreement with
Anthropic regarding use of Anthropic's services. If no separate agreement
exists, use is governed by Anthropic's Consumer Terms of Service or
Commercial Terms of Service, as applicable:
https://www.anthropic.com/legal/consumer-terms
https://www.anthropic.com/legal/commercial-terms
Your applicable agreement is referred to as the "Agreement." "Services" are
as defined in the Agreement.

ADDITIONAL RESTRICTIONS: Notwithstanding anything in the Agreement to the
contrary, users may not:

- Extract these materials from the Services or retain copies of these
  materials outside the Services
- Reproduce or copy these materials, except for temporary copies created
  automatically during authorized use of the Services
- Create derivative works based on these materials
- Distribute, sublicense, or transfer these materials to any third party
- Make, offer to sell, sell, or import any inventions embodied in these
  materials
- Reverse engineer, decompile, or disassemble these materials

The receipt, viewing, or possession of these materials does not convey or
imply any license or right beyond those expressly granted above.

Anthropic retains all right, title, and interest in these materials,
including all copyrights, patents, and other intellectual property rights.

#!/usr/bin/env python3
"""
Excel Formula Recalculation Script
Recalculates all formulas in an Excel file using LibreOffice
"""

import json
import sys
import subprocess
import os
import platform
from pathlib import Path
from openpyxl import load_workbook


def setup_libreoffice_macro():
    """Setup LibreOffice macro for recalculation if not already configured"""
    if platform.system() == 'Darwin':
        macro_dir = os.path.expanduser('~/Library/Application Support/LibreOffice/4/user/basic/Standard')
    else:
        macro_dir = os.path.expanduser('~/.config/libreoffice/4/user/basic/Standard')
    
    macro_file = os.path.join(macro_dir, 'Module1.xba')
    
    if os.path.exists(macro_file):
        with open(macro_file, 'r') as f:
            if 'RecalculateAndSave' in f.read():
                return True
    
    if not os.path.exists(macro_dir):
        subprocess.run(['soffice', '--headless', '--terminate_after_init'], 
                      capture_output=True, timeout=10)
        os.makedirs(macro_dir, exist_ok=True)
    
    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="StarBasic">
    Sub RecalculateAndSave()
      ThisComponent.calculateAll()
      ThisComponent.store()
      ThisComponent.close(True)
    End Sub
</script:module>'''
    
    try:
        with open(macro_file, 'w') as f:
            f.write(macro_content)
        return True
    except Exception:
        return False


def recalc(filename, timeout=30):
    """
    Recalculate formulas in Excel file and report any errors
    
    Args:
        filename: Path to Excel file
        timeout: Maximum time to wait for recalculation (seconds)
    
    Returns:
        dict with error locations and counts
    """
    if not Path(filename).exists():
        return {'error': f'File {filename} does not exist'}
    
    abs_path = str(Path(filename).absolute())
    
    if not setup_libreoffice_macro():
        return {'error': 'Failed to setup LibreOffice macro'}
    
    cmd = [
        'soffice', '--headless', '--norestore',
        'vnd.sun.star.script:Standard.Module1.RecalculateAndSave?language=Basic&location=application',
        abs_path
    ]
    
    # Handle timeout command differences between Linux and macOS
    if platform.system() != 'Windows':
        timeout_cmd = 'timeout' if platform.system() == 'Linux' else None
        if platform.system() == 'Darwin':
            # Check if gtimeout is available on macOS
            try:
                subprocess.run(['gtimeout', '--version'], capture_output=True, timeout=1, check=False)
                timeout_cmd = 'gtimeout'
            except (FileNotFoundError, subprocess.TimeoutExpired):
                pass
        
        if timeout_cmd:
            cmd = [timeout_cmd, str(timeout)] + cmd
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    if result.returncode != 0 and result.returncode != 124:  # 124 is timeout exit code
        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'}
        else:
            return {'error': error_msg}
    
    # Check for Excel errors in the recalculated file - scan ALL cells
    try:
        wb = load_workbook(filename, data_only=True)
        
        excel_errors = ['#VALUE!', '#DIV/0!', '#REF!', '#NAME?', '#NULL!', '#NUM!', '#N/A']
        error_details = {err: [] for err in excel_errors}
        total_errors = 0
        
        for sheet_name in wb.sheetnames:
            ws = wb[sheet_name]
            # Check ALL rows and columns - no limits
            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()
        
        # Build result summary
        result = {
            'status': 'success' if total_errors == 0 else 'errors_found',
            'total_errors': total_errors,
            'error_summary': {}
        }
        
        # Add non-empty error categories
        for err_type, locations in error_details.items():
            if locations:
                result['error_summary'][err_type] = {
                    'count': len(locations),
                    'locations': locations[:20]  # Show up to 20 locations
                }
        
        # Add formula count for context - also check ALL cells
        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
        
    except Exception as e:
        return {'error': str(e)}


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")
        sys.exit(1)
    
    filename = 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))


if __name__ == '__main__':
    main()

{
  "schema_version": "2.0",
  "meta": {
    "generated_at": "2026-01-17T08:51:28.469Z",
    "slug": "xlsx",
    "source_url": "https://github.com/anthropics/skills/tree/main/skills/xlsx",
    "source_ref": "main",
    "model": "claude",
    "analysis_version": "3.0.0",
    "source_type": "official",
    "content_hash": "020ccdb5932257b66c638ec1157ea248d57fa52c8c01f1f68b559b5970c7df35",
    "tree_hash": "948d29064bffd8a76f096c2c31edb777f603cbd6cc9dda18d45bc82710d4f31b"
  },
  "skill": {
    "name": "xlsx",
    "description": "Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas",
    "summary": "Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, dat...",
    "icon": "📊",
    "version": "1.0.0",
    "author": "anthropics",
    "license": "Proprietary. LICENSE.txt has complete terms",
    "category": "data",
    "tags": [
      "spreadsheets",
      "excel",
      "data-analysis",
      "formulas"
    ],
    "supported_tools": [
      "claude",
      "codex",
      "claude-code"
    ],
    "risk_factors": [
      "external_commands",
      "filesystem"
    ]
  },
  "security_audit": {
    "risk_level": "safe",
    "is_blocked": false,
    "safe_to_publish": true,
    "summary": "Official Anthropic skill for spreadsheet operations. Uses openpyxl and pandas for file manipulation. recalc.py script runs LibreOffice as subprocess for formula recalculation. All file operations are local, no network access, no dangerous patterns detected.",
    "risk_factor_evidence": [
      {
        "factor": "external_commands",
        "evidence": [
          {
            "file": "recalc.py",
            "line_start": 72,
            "line_end": 92
          }
        ]
      },
      {
        "factor": "filesystem",
        "evidence": [
          {
            "file": "recalc.py",
            "line_start": 45,
            "line_end": 50
          }
        ]
      }
    ],
    "critical_findings": [],
    "high_findings": [],
    "medium_findings": [],
    "low_findings": [],
    "dangerous_patterns": [],
    "files_scanned": 2,
    "total_lines": 378,
    "audit_model": "claude",
    "audited_at": "2026-01-17T08:51:28.469Z"
  },
  "content": {
    "user_title": "Build Excel Spreadsheets with Formulas",
    "value_statement": "Creating and editing Excel spreadsheets with formulas requires precision and Excel-specific knowledge. This skill provides comprehensive tools for spreadsheet creation, data analysis, and formula management using best practices for financial modeling and reporting.",
    "seo_keywords": [
      "excel",
      "xlsx",
      "spreadsheets",
      "formulas",
      "data analysis",
      "claude",
      "codex",
      "claude code",
      "openpyxl",
      "pandas"
    ],
    "actual_capabilities": [
      "Create new Excel spreadsheets with formulas, formatting, and styling",
      "Read and analyze spreadsheet data using pandas for data manipulation",
      "Edit existing Excel files while preserving formulas and formatting",
      "Recalculate formulas and verify spreadsheet accuracy using LibreOffice",
      "Apply industry-standard color coding and formatting conventions for financial models"
    ],
    "limitations": [
      "Formula recalculation requires LibreOffice installation on the system",
      "Cannot edit encrypted or password-protected Excel files",
      "Complex VBA macros are not supported - only Excel formulas and basic formatting"
    ],
    "use_cases": [
      {
        "target_user": "Financial Analysts",
        "title": "Build Financial Models",
        "description": "Create discounted cash flow models, valuation spreadsheets, and financial projections with proper formatting and formula structure."
      },
      {
        "target_user": "Data Scientists",
        "title": "Export Analysis Results",
        "description": "Export pandas data analysis results to formatted Excel files with charts and summary statistics for stakeholder reports."
      },
      {
        "target_user": "Business Users",
        "title": "Automate Spreadsheet Tasks",
        "description": "Generate budget templates, expense reports, and data summaries from raw data sources with consistent formatting."
      }
    ],
    "prompt_templates": [
      {
        "title": "Create Simple Spreadsheet",
        "scenario": "New file with data and totals",
        "prompt": "Create an Excel file named sales_report.xlsx with a sheet containing monthly sales data in columns A and B, with a formula in column C that calculates the year-over-year growth percentage."
      },
      {
        "title": "Analyze Existing Data",
        "scenario": "Read and summarize spreadsheet contents",
        "prompt": "Read the data from quarterly_results.xlsx and provide a summary of the key metrics, including total revenue, average expenses, and profit margins by category."
      },
      {
        "title": "Edit with Formulas",
        "scenario": "Add calculations to existing file",
        "prompt": "Add a new column to budget_template.xlsx that calculates the variance between projected and actual amounts, using conditional formatting to highlight positive and negative variances."
      },
      {
        "title": "Build Complex Model",
        "scenario": "Multi-sheet financial model",
        "prompt": "Create a three-sheet financial model: assumptions sheet with growth rates and margins, income statement with all formulas linked to assumptions, and a summary dashboard with key metrics and charts."
      }
    ],
    "output_examples": [
      {
        "input": "Create a sales summary spreadsheet with quarterly data and year-over-year comparisons",
        "output": [
          "Created sales_summary.xlsx with quarterly sales data",
          "Added formula columns for YoY growth and running totals",
          "Applied color coding: blue for inputs, black for formulas",
          "Formatted currency columns with $ symbols and thousands separators"
        ]
      },
      {
        "input": "Analyze the data in financial_report.xlsx and identify any formula errors",
        "output": [
          "Scanned all 5 sheets for formula errors",
          "Found 3 #REF! errors in the projections sheet",
          "Identified broken cell references from deleted rows",
          "Fixed references and verified all formulas now calculate correctly"
        ]
      }
    ],
    "best_practices": [
      "Always use Excel formulas instead of hardcoding calculated values to keep spreadsheets dynamic and updateable",
      "Place assumptions in separate cells and reference them in formulas rather than using literal values",
      "Verify formulas by testing edge cases including zero values, negative numbers, and empty cells"
    ],
    "anti_patterns": [
      "Calculating values in Python and hardcoding the results instead of using Excel formulas",
      "Mixing hardcoded values and formulas without clear color coding or documentation",
      "Saving files with data_only=True mode which permanently replaces formulas with static values"
    ],
    "faq": [
      {
        "question": "What Excel file formats are supported?",
        "answer": "Supports .xlsx, .xlsm, .csv, and .tsv formats for reading and writing spreadsheets."
      },
      {
        "question": "Does this skill work with Google Sheets?",
        "answer": "This skill focuses on Excel files. For Google Sheets, a different integration would be required."
      },
      {
        "question": "Can this skill edit VBA macros?",
        "answer": "The skill works with Excel formulas and formatting but does not support editing VBA macro code."
      },
      {
        "question": "Why is LibreOffice needed for formula recalculation?",
        "answer": "LibreOffice calculates formulas and updates their values, which openpyxl cannot do as it only stores formulas as text."
      },
      {
        "question": "What happens to existing formatting when editing files?",
        "answer": "The skill preserves existing formatting and formulas. Changes are made while maintaining the original structure."
      },
      {
        "question": "Is this skill available on all Claude platforms?",
        "answer": "Yes, this skill is supported on Claude, Codex, and Claude Code for spreadsheet operations."
      }
    ]
  },
  "file_structure": [
    {
      "name": "LICENSE.txt",
      "type": "file",
      "path": "LICENSE.txt",
      "lines": 31
    },
    {
      "name": "recalc.py",
      "type": "file",
      "path": "recalc.py",
      "lines": 178
    },
    {
      "name": "SKILL.md",
      "type": "file",
      "path": "SKILL.md",
      "lines": 289
    }
  ]
}