devskill 2.0.6 → 2.0.8

package/skills/write-coding-standards-from-file/SKILL.md

@@ -0,0 +1,316 @@
+---
+name: write-coding-standards-from-file
+description: 'Write a coding standards document for a project using the coding styles from the file(s) and/or folder(s) passed as arguments in the prompt.'
+---
+
+# Write Coding Standards From File
+
+Use the existing syntax of the file(s) to establish the standards and style guides for the project. If more than one file or a folder is passed, loop through each file or files in the folder, appending the file's data to temporary memory or a file, then when complete use temporary data as a single instance; as if it were the file name to base the standards and style guideline on.
+
+## Rules and Configuration
+
+Below is a set of quasi-configuration `boolean` and `string[]` variables. Conditions for handling `true`, or other values for each variable are under the level two heading `## Variable and Parameter Configuration Conditions`.
+
+Parameters for the prompt have a text definition. There is one required parameter **`${fileName}`**, and several optional parameters **`${folderName}`**, **`${instructions}`**, and any **`[configVariableAsParameter]`**.
+
+### Configuration Variables
+
+* addStandardsTest = false;
+* addToREADME = false;
+* addToREADMEInsertions = ["atBegin", "middle", "beforeEnd", "bestFitUsingContext"];
+  - Default to **beforeEnd**.
+* createNewFile = true;
+* fetchStyleURL = true;
+* findInconsistencies = true;
+* fixInconsistencies = true;
+* newFileName = ["CONTRIBUTING.md", "STYLE.md", "CODE_OF_CONDUCT.md", "CODING_STANDARDS.md", "DEVELOPING.md", "CONTRIBUTION_GUIDE.md", "GUIDELINES.md", "PROJECT_STANDARDS.md", "BEST_PRACTICES.md", "HACKING.md"];
+  - For each file in `${newFileName}`, if file does not exist, use that file name and `break`, else continue to next file name of `${newFileName}`.
+* outputSpecToPrompt = false;
+* useTemplate = "verbose"; // or "v"
+  - Possible values are `[["v", "verbose"], ["m", "minimal"], ["b", "best fit"], ["custom"]]`.
+  - Selects one of the two example templates at the bottom of prompt file under the level two heading `## Coding Standards Templates`, or use another composition that is a better fit.
+  - If **custom**, then apply per request.
+
+### Configuration Variables as Prompt Parameters
+
+If any of the variable names are passed to prompt as-is, or as a similar but clearly related text value, then override the default variable value with the value passed to prompt.
+
+### Prompt Parameters
+
+* **fileName** = The name of the file that will be analyzed in terms of: indentation, variable naming, commenting, conditional procedures, functional procedures, and other syntax related data for the coding language of the file.
+* folderName = The name of the folder that will be used to extract data from multiple files into one aggregated dataset that will be analyzed in terms of: indentation, variable naming, commenting, conditional procedures, functional procedures, and other syntax related data for the coding language of the files.
+* instructions = Additional instructions, rules, and procedures that will be provided for unique cases.
+* [configVariableAsParameter] = If passed will override the default state of the configuration variable. Example:
+  - useTemplate = If passed will override the configuration `${useTemplate}` default. Values are `[["v", "verbose"], ["m", "minimal"], ["b", "best fit"]]`.
+
+#### Required and Optional Parameters
+
+* **fileName** - required
+* folderName - *optional*
+* instructions - *optional*
+* [configVariableAsParameter] - *optional*
+
+## Variable and Parameter Configuration Conditions
+
+### `${fileName}.length > 1 || ${folderName} != undefined`
+
+* If true, toggle `${fixInconsistencies}` to false.
+
+### `${addToREADME} == true`
+
+* Insert the coding standards into the `README.md` instead of outputting to the prompt or creating a new file.
+* If true, toggle both `${createNewFile}` and `${outputSpecToPrompt}` to false.
+
+### `${addToREADMEInsertions} == "atBegin"`
+
+* If `${addToREADME}` is true, then insert the coding standards data at the **beginning** of the `README.md` file after the title.
+
+### `${addToREADMEInsertions} == "middle"`
+
+* If `${addToREADME}` is true, then insert the coding standards data at the **middle** of the `README.md` file, changing the standards title heading to match that of the `README.md` composition.
+
+### `${addToREADMEInsertions} == "beforeEnd"`
+
+* If `${addToREADME}` is true, then insert the coding standards data at the **end** of the `README.md` file, inserting a new line after the last character, then inserting the data on a new line.
+
+### `${addToREADMEInsertions} == "bestFitUsingContext"`
+
+* If `${addToREADME}` is true, then insert the coding standards data at the **best fitting line** of the `README.md` file in regards to the context of the `README.md` composition and flow of data.
+
+### `${addStandardsTest} == true`
+
+* Once the coding standards file is complete, write a test file to ensure the file or files passed to it adhere to the coding standards.
+
+### `${createNewFile} == true`
+
+* Create a new file using the value, or one of the possible values, from `${newFileName}`.
+* If true, toggle both `${outputSpecToPrompt}` and `${addToREADME}` to false.
+
+### `${fetchStyleURL} == true`
+
+* Additionally use the data fetched from the links nested under level three heading `### Fetch Links` as context for creating standards, specifications, and styling data for the new file, prompt, or `README.md`.
+* For each relevant item in `### Fetch Links`, run `#fetch ${item}`.
+
+### `${findInconsistencies} == true`
+
+* Evaluate syntax related to indentations, line-breaks, comments, conditional and function nesting, quotation wrappers i.e. `'` or `"` for strings, etc., and categorize.
+* For each category, make a count, and if one item does not match the majority of the count, then commit to temporary memory.
+* Depending on the status of `${fixInconsistencies}`, either edit and fix the low count categories to match the majority, or output to prompt inconsistencies stored in temporary memory.
+
+### `${fixInconsistencies} == true`
+
+* Edit and fix the low count categories of syntax data to match the majority of corresponding syntax data using inconsistencies stored in temporary memory.
+
+### `typeof ${newFileName} == "string"`
+
+* If specifically defined as a `string`, create a new file using the value from `${newFileName}`.
+
+### `typeof ${newFileName} != "string"`
+
+* If **NOT** specifically defined as a `string`, but instead an `object` or an array, create a new file using a value from `${newFileName}` by applying this rule:
+  - For each file name in `${newFileName}`, if file does not exist, use that file name and `break`, else continue to the next.
+
+### `${outputSpecToPrompt} == true`
+
+* Output the coding standards to the prompt instead of creating a file or adding to README.
+* If true, toggle both `${createNewFile}` and `${addToREADME}` to false.
+
+### `${useTemplate} == "v" || ${useTemplate} == "verbose"`
+
+* Use data under the level three heading `### "v", "verbose"` as guiding template when composing the data for coding standards.
+
+### `${useTemplate} == "m" || ${useTemplate} == "minimal"`
+
+* Use data under the level three heading `### "m", "minimal"` as guiding template when composing the data for coding standards.
+
+### `${useTemplate} == "b" || ${useTemplate} == "best"`
+
+* Use either the data under the level three heading `### "v", "verbose"` or `### "m", "minimal"`, depending on the data extracted from `${fileName}`, and use the best fit as guiding template when composing the data for coding standards.
+
+### `${useTemplate} == "custom" || ${useTemplate} == "<ANY_NAME>"`
+
+* Use the custom prompt, instructions, template, or other data passed as guiding template when composing the data for coding standards.
+
+## **if** `${fetchStyleURL} == true`
+
+Depending on the programming language, for each link in list below, run `#fetch (URL)`, if programming language is `${fileName} == [<Language> Style Guide]`.
+
+### Fetch Links
+
+- [C Style Guide](https://users.ece.cmu.edu/~eno/coding/CCodingStandard.html)
+- [C# Style Guide](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/coding-conventions)
+- [C++ Style Guide](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines)
+- [Go Style Guide](https://github.com/golang-standards/project-layout)
+- [Java Style Guide](https://coderanch.com/wiki/718799/Style)
+- [AngularJS App Style Guide](https://github.com/mgechev/angularjs-style-guide)
+- [jQuery Style Guide](https://contribute.jquery.org/style-guide/js/)
+- [JavaScript Style Guide](https://www.w3schools.com/js/js_conventions.asp)
+- [JSON Style Guide](https://google.github.io/styleguide/jsoncstyleguide.xml)
+- [Kotlin Style Guide](https://kotlinlang.org/docs/coding-conventions.html)
+- [Markdown Style Guide](https://cirosantilli.com/markdown-style-guide/)
+- [Perl Style Guide](https://perldoc.perl.org/perlstyle)
+- [PHP Style Guide](https://phptherightway.com/)
+- [Python Style Guide](https://peps.python.org/pep-0008/)
+- [Ruby Style Guide](https://rubystyle.guide/)
+- [Rust Style Guide](https://github.com/rust-lang/rust/tree/HEAD/src/doc/style-guide/src)
+- [Swift Style Guide](https://www.swift.org/documentation/api-design-guidelines/)
+- [TypeScript Style Guide](https://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html)
+- [Visual Basic Style Guide](https://en.wikibooks.org/wiki/Visual_Basic/Coding_Standards)
+- [Shell Script Style Guide](https://google.github.io/styleguide/shellguide.html)
+- [Git Usage Style Guide](https://github.com/agis/git-style-guide)
+- [PowerShell Style Guide](https://github.com/PoshCode/PowerShellPracticeAndStyle)
+- [CSS](https://cssguidelin.es/)
+- [Sass Style Guide](https://sass-guidelin.es/)
+- [HTML Style Guide](https://github.com/marcobiedermann/html-style-guide)
+- [Linux kernel Style Guide](https://www.kernel.org/doc/html/latest/process/coding-style.html)
+- [Node.js Style Guide](https://github.com/felixge/node-style-guide)
+- [SQL Style Guide](https://www.sqlstyle.guide/)
+- [Angular Style Guide](https://angular.dev/style-guide)
+- [Vue Style Guide](https://vuejs.org/style-guide/rules-strongly-recommended.html)
+- [Django Style Guide](https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/coding-style/)
+- [SystemVerilog Style Guide](https://github.com/lowRISC/style-guides/blob/master/VerilogCodingStyle.md)
+
+## Coding Standards Templates
+
+### `"m", "minimal"`
+
+```text
+    ```markdown
+    ## 1. Introduction
+    *   **Purpose:** Briefly explain why the coding standards are being established (e.g., to improve code quality, maintainability, and team collaboration).
+    *   **Scope:** Define which languages, projects, or modules this specification applies to.
+
+    ## 2. Naming Conventions
+    *   **Variables:** `camelCase`
+    *   **Functions/Methods:** `PascalCase` or `camelCase`.
+    *   **Classes/Structs:** `PascalCase`.
+    *   **Constants:** `UPPER_SNAKE_CASE`.
+
+    ## 3. Formatting and Style
+    *   **Indentation:** Use 4 spaces per indent (or tabs).
+    *   **Line Length:** Limit lines to a maximum of 80 or 120 characters.
+    *   **Braces:** Use the "K&R" style (opening brace on the same line) or the "Allman" style (opening brace on a new line).
+    *   **Blank Lines:** Specify how many blank lines to use for separating logical blocks of code.
+
+    ## 4. Commenting
+    *   **Docstrings/Function Comments:** Describe the function's purpose, parameters, and return values.
+    *   **Inline Comments:** Explain complex or non-obvious logic.
+    *   **File Headers:** Specify what information should be included in a file header, such as author, date, and file description.
+
+    ## 5. Error Handling
+    *   **General:** How to handle and log errors.
+    *   **Specifics:** Which exception types to use, and what information to include in error messages.
+
+    ## 6. Best Practices and Anti-Patterns
+    *   **General:** List common anti-patterns to avoid (e.g., global variables, magic numbers).
+    *   **Language-specific:** Specific recommendations based on the project's programming language.
+
+    ## 7. Examples
+    *   Provide a small code example demonstrating the correct application of the rules.
+    *   Provide a small code example of an incorrect implementation and how to fix it.
+
+    ## 8. Contribution and Enforcement
+    *   Explain how the standards are to be enforced (e.g., via code reviews).
+    *   Provide a guide for contributing to the standards document itself.
+    ```
+```
+
+### `"v", verbose"`
+
+```text
+    ```markdown
+
+    # Style Guide
+
+    This document defines the style and conventions used in this project.
+    All contributions should follow these rules unless otherwise noted.
+
+    ## 1. General Code Style
+
+    - Favor clarity over brevity.
+    - Keep functions and methods small and focused.
+    - Avoid repeating logic; prefer shared helpers/utilities.
+    - Remove unused variables, imports, code paths, and files.
+
+    ## 2. Naming Conventions
+
+    Use descriptive names. Avoid abbreviations unless well-known.
+
+    | Item            | Convention           | Example            |
+    |-----------------|----------------------|--------------------|
+    | Variables       | `lower_snake_case`   | `buffer_size`      |
+    | Functions       | `lower_snake_case()` | `read_file()`      |
+    | Constants       | `UPPER_SNAKE_CASE`   | `MAX_RETRIES`      |
+    | Types/Structs   | `PascalCase`         | `FileHeader`       |
+    | File Names      | `lower_snake_case`   | `file_reader.c`    |
+
+    ## 3. Formatting Rules
+
+    - Indentation: **4 spaces**
+    - Line length: **max 100 characters**
+    - Encoding: **UTF-8**, no BOM
+    - End files with a newline
+
+    ### Braces (example in C, adjust for your language)
+
+        ```c
+        if (condition) {
+            do_something();
+        } else {
+            do_something_else();
+        }
+        ```
+
+    ### Spacing
+
+    - One space after keywords: `if (x)`, not `if(x)`
+    - One blank line between top-level functions
+
+    ## 4. Comments & Documentation
+
+    - Explain *why*, not *what*, unless intent is unclear.
+    - Keep comments up-to-date as code changes.
+    - Public functions should include a short description of purpose and parameters.
+
+    Recommended tags:
+
+        ```text
+        TODO: follow-up work
+        FIXME: known incorrect behavior
+        NOTE: non-obvious design decision
+        ```
+
+    ## 5. Error Handling
+
+    - Handle error conditions explicitly.
+    - Avoid silent failures; either return errors or log them appropriately.
+    - Clean up resources (files, memory, handles) before returning on failure.
+
+    ## 6. Commit & Review Practices
+
+    ### Commits
+    - One logical change per commit.
+    - Write clear commit messages:
+
+        ```text
+        Short summary (max ~50 chars)
+        Optional longer explanation of context and rationale.
+        ```
+
+    ### Reviews
+    - Keep pull requests reasonably small.
+    - Be respectful and constructive in review discussions.
+    - Address requested changes or explain if you disagree.
+
+    ## 7. Tests
+
+    - Write tests for new functionality.
+    - Tests should be deterministic (no randomness without seeding).
+    - Prefer readable test cases over complex test abstraction.
+
+    ## 8. Changes to This Guide
+
+    Style evolves.
+    Propose improvements by opening an issue or sending a patch updating this document.
+    ```
+```

package/skills/write-coding-standards-from-file/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/awesome-copilot/skills/write-coding-standards-from-file`
+- **Git SHA:** `23fb7006c132a0bba75b0e5af7a35cab11272812`
+- **Synced:** 2026-03-24

package/skills/xlsx/LICENSE.txt

@@ -0,0 +1,30 @@
+© 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.

package/skills/xlsx/SKILL.md

@@ -0,0 +1,292 @@
+---
+name: xlsx
+description: "Use this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like \"the xlsx in my downloads\") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved."
+license: Proprietary. LICENSE.txt has complete terms
+---
+
+# Requirements for Outputs
+
+## All Excel files
+
+### Professional Font
+- Use a consistent, professional font (e.g., Arial, Times New Roman) for all deliverables unless otherwise instructed by the user
+
+### Zero Formula Errors
+- Every Excel model MUST be delivered with ZERO formula errors (#REF!, #DIV/0!, #VALUE!, #N/A, #NAME?)
+
+### Preserve Existing Templates (when updating templates)
+- Study and EXACTLY match existing format, style, and conventions when modifying files
+- Never impose standardized formatting on files with established patterns
+- Existing template conventions ALWAYS override these guidelines
+
+## Financial models
+
+### Color Coding Standards
+Unless otherwise stated by the user or existing template
+
+#### Industry-Standard Color Conventions
+- **Blue text (RGB: 0,0,255)**: Hardcoded inputs, and numbers users will change for scenarios
+- **Black text (RGB: 0,0,0)**: ALL formulas and calculations
+- **Green text (RGB: 0,128,0)**: Links pulling from other worksheets within same workbook
+- **Red text (RGB: 255,0,0)**: External links to other files
+- **Yellow background (RGB: 255,255,0)**: Key assumptions needing attention or cells that need to be updated
+
+### Number Formatting Standards
+
+#### Required Format Rules
+- **Years**: Format as text strings (e.g., "2024" not "2,024")
+- **Currency**: Use $#,##0 format; ALWAYS specify units in headers ("Revenue ($mm)")
+- **Zeros**: Use number formatting to make all zeros "-", including percentages (e.g., "$#,##0;($#,##0);-")
+- **Percentages**: Default to 0.0% format (one decimal)
+- **Multiples**: Format as 0.0x for valuation multiples (EV/EBITDA, P/E)
+- **Negative numbers**: Use parentheses (123) not minus -123
+
+### Formula Construction Rules
+
+#### Assumptions Placement
+- Place ALL assumptions (growth rates, margins, multiples, etc.) in separate assumption cells
+- Use cell references instead of hardcoded values in formulas
+- Example: Use =B5*(1+$B$6) instead of =B5*1.05
+
+#### Formula Error Prevention
+- Verify all cell references are correct
+- Check for off-by-one errors in ranges
+- Ensure consistent formulas across all projection periods
+- Test with edge cases (zero values, negative numbers)
+- Verify no unintended circular references
+
+#### Documentation Requirements for Hardcodes
+- Comment or in cells beside (if end of table). Format: "Source: [System/Document], [Date], [Specific Reference], [URL if applicable]"
+- Examples:
+  - "Source: Company 10-K, FY2024, Page 45, Revenue Note, [SEC EDGAR URL]"
+  - "Source: Company 10-Q, Q2 2025, Exhibit 99.1, [SEC EDGAR URL]"
+  - "Source: Bloomberg Terminal, 8/15/2025, AAPL US Equity"
+  - "Source: FactSet, 8/20/2025, Consensus Estimates Screen"
+
+# XLSX creation, editing, and analysis
+
+## Overview
+
+A user may ask you to create, edit, or analyze the contents of an .xlsx file. You have different tools and workflows available for different tasks.
+
+## Important Requirements
+
+**LibreOffice Required for Formula Recalculation**: You can assume LibreOffice is installed for recalculating formula values using the `scripts/recalc.py` script. The script automatically configures LibreOffice on first run, including in sandboxed environments where Unix sockets are restricted (handled by `scripts/office/soffice.py`)
+
+## Reading and analyzing data
+
+### Data analysis with pandas
+For data analysis, visualization, and basic operations, use **pandas** which provides powerful data manipulation capabilities:
+
+```python
+import pandas as pd
+
+# Read Excel
+df = pd.read_excel('file.xlsx')  # Default: first sheet
+all_sheets = pd.read_excel('file.xlsx', sheet_name=None)  # All sheets as dict
+
+# Analyze
+df.head()      # Preview data
+df.info()      # Column info
+df.describe()  # Statistics
+
+# Write Excel
+df.to_excel('output.xlsx', index=False)
+```
+
+## Excel File Workflows
+
+## CRITICAL: Use Formulas, Not Hardcoded Values
+
+**Always use Excel formulas instead of calculating values in Python and hardcoding them.** This ensures the spreadsheet remains dynamic and updateable.
+
+### ❌ WRONG - Hardcoding Calculated Values
+```python
+# Bad: Calculating in Python and hardcoding result
+total = df['Sales'].sum()
+sheet['B10'] = total  # Hardcodes 5000
+
+# Bad: Computing growth rate in Python
+growth = (df.iloc[-1]['Revenue'] - df.iloc[0]['Revenue']) / df.iloc[0]['Revenue']
+sheet['C5'] = growth  # Hardcodes 0.15
+
+# Bad: Python calculation for average
+avg = sum(values) / len(values)
+sheet['D20'] = avg  # Hardcodes 42.5
+```
+
+### ✅ CORRECT - Using Excel Formulas
+```python
+# Good: Let Excel calculate the sum
+sheet['B10'] = '=SUM(B2:B9)'
+
+# Good: Growth rate as Excel formula
+sheet['C5'] = '=(C4-C2)/C2'
+
+# Good: Average using Excel function
+sheet['D20'] = '=AVERAGE(D2:D19)'
+```
+
+This applies to ALL calculations - totals, percentages, ratios, differences, etc. The spreadsheet should be able to recalculate when source data changes.
+
+## Common Workflow
+1. **Choose tool**: pandas for data, openpyxl for formulas/formatting
+2. **Create/Load**: Create new workbook or load existing file
+3. **Modify**: Add/edit data, formulas, and formatting
+4. **Save**: Write to file
+5. **Recalculate formulas (MANDATORY IF USING FORMULAS)**: Use the scripts/recalc.py script
+   ```bash
+   python scripts/recalc.py output.xlsx
+   ```
+6. **Verify and fix any errors**: 
+   - The script returns JSON with error details
+   - If `status` is `errors_found`, check `error_summary` for specific error types and locations
+   - Fix the identified errors and recalculate again
+   - Common errors to fix:
+     - `#REF!`: Invalid cell references
+     - `#DIV/0!`: Division by zero
+     - `#VALUE!`: Wrong data type in formula
+     - `#NAME?`: Unrecognized formula name
+
+### Creating new Excel files
+
+```python
+# Using openpyxl for formulas and formatting
+from openpyxl import Workbook
+from openpyxl.styles import Font, PatternFill, Alignment
+
+wb = Workbook()
+sheet = wb.active
+
+# Add data
+sheet['A1'] = 'Hello'
+sheet['B1'] = 'World'
+sheet.append(['Row', 'of', 'data'])
+
+# Add formula
+sheet['B2'] = '=SUM(A1:A10)'
+
+# Formatting
+sheet['A1'].font = Font(bold=True, color='FF0000')
+sheet['A1'].fill = PatternFill('solid', start_color='FFFF00')
+sheet['A1'].alignment = Alignment(horizontal='center')
+
+# Column width
+sheet.column_dimensions['A'].width = 20
+
+wb.save('output.xlsx')
+```
+
+### Editing existing Excel files
+
+```python
+# Using openpyxl to preserve formulas and formatting
+from openpyxl import load_workbook
+
+# Load existing file
+wb = load_workbook('existing.xlsx')
+sheet = wb.active  # or wb['SheetName'] for specific sheet
+
+# Working with multiple sheets
+for sheet_name in wb.sheetnames:
+    sheet = wb[sheet_name]
+    print(f"Sheet: {sheet_name}")
+
+# Modify cells
+sheet['A1'] = 'New Value'
+sheet.insert_rows(2)  # Insert row at position 2
+sheet.delete_cols(3)  # Delete column 3
+
+# Add new sheet
+new_sheet = wb.create_sheet('NewSheet')
+new_sheet['A1'] = 'Data'
+
+wb.save('modified.xlsx')
+```
+
+## Recalculating formulas
+
+Excel files created or modified by openpyxl contain formulas as strings but not calculated values. Use the provided `scripts/recalc.py` script to recalculate formulas:
+
+```bash
+python scripts/recalc.py <excel_file> [timeout_seconds]
+```
+
+Example:
+```bash
+python scripts/recalc.py output.xlsx 30
+```
+
+The script:
+- Automatically sets up LibreOffice macro on first run
+- Recalculates all formulas in all sheets
+- Scans ALL cells for Excel errors (#REF!, #DIV/0!, etc.)
+- Returns JSON with detailed error locations and counts
+- Works on both Linux and macOS
+
+## Formula Verification Checklist
+
+Quick checks to ensure formulas work correctly:
+
+### Essential Verification
+- [ ] **Test 2-3 sample references**: Verify they pull correct values before building full model
+- [ ] **Column mapping**: Confirm Excel columns match (e.g., column 64 = BL, not BK)
+- [ ] **Row offset**: Remember Excel rows are 1-indexed (DataFrame row 5 = Excel row 6)
+
+### Common Pitfalls
+- [ ] **NaN handling**: Check for null values with `pd.notna()`
+- [ ] **Far-right columns**: FY data often in columns 50+ 
+- [ ] **Multiple matches**: Search all occurrences, not just first
+- [ ] **Division by zero**: Check denominators before using `/` in formulas (#DIV/0!)
+- [ ] **Wrong references**: Verify all cell references point to intended cells (#REF!)
+- [ ] **Cross-sheet references**: Use correct format (Sheet1!A1) for linking sheets
+
+### Formula Testing Strategy
+- [ ] **Start small**: Test formulas on 2-3 cells before applying broadly
+- [ ] **Verify dependencies**: Check all cells referenced in formulas exist
+- [ ] **Test edge cases**: Include zero, negative, and very large values
+
+### Interpreting scripts/recalc.py Output
+The script returns JSON with error details:
+```json
+{
+  "status": "success",           // or "errors_found"
+  "total_errors": 0,              // Total error count
+  "total_formulas": 42,           // Number of formulas in file
+  "error_summary": {              // Only present if errors found
+    "#REF!": {
+      "count": 2,
+      "locations": ["Sheet1!B5", "Sheet1!C10"]
+    }
+  }
+}
+```
+
+## Best Practices
+
+### Library Selection
+- **pandas**: Best for data analysis, bulk operations, and simple data export
+- **openpyxl**: Best for complex formatting, formulas, and Excel-specific features
+
+### Working with openpyxl
+- Cell indices are 1-based (row=1, column=1 refers to cell A1)
+- Use `data_only=True` to read calculated values: `load_workbook('file.xlsx', data_only=True)`
+- **Warning**: If opened with `data_only=True` and saved, formulas are replaced with values and permanently lost
+- For large files: Use `read_only=True` for reading or `write_only=True` for writing
+- Formulas are preserved but not evaluated - use scripts/recalc.py to update values
+
+### Working with pandas
+- Specify data types to avoid inference issues: `pd.read_excel('file.xlsx', dtype={'id': str})`
+- For large files, read specific columns: `pd.read_excel('file.xlsx', usecols=['A', 'C', 'E'])`
+- Handle dates properly: `pd.read_excel('file.xlsx', parse_dates=['date_column'])`
+
+## Code Style Guidelines
+**IMPORTANT**: When generating Python code for Excel operations:
+- Write minimal, concise Python code without unnecessary comments
+- Avoid verbose variable names and redundant operations
+- Avoid unnecessary print statements
+
+**For Excel files themselves**:
+- Add comments to cells with complex formulas or important assumptions
+- Document data sources for hardcoded values
+- Include notes for key calculations and model sections

package/skills/xlsx/SYNC.md

@@ -0,0 +1,5 @@
+# Sync Info
+
+- **Source:** `vendor/anthropics/skills/xlsx`
+- **Git SHA:** `887114fd09f8f24a7e6c907f9ee505348498ab6a`
+- **Synced:** 2026-03-24