[Feature]: Rich Spreadsheet Skill (xlsx / csv)

[raphael-solace]

Current behavior

hermes-agent can read and write files with its terminal tool, but Excel/spreadsheet handling relies on raw Python (openpyxl, pandas) with no structured abstraction. The agent has to figure out the library, the sheet structure, and error handling from scratch every time. This leads to inconsistent results — formatting is lost on round-trips, the wrong library is chosen for the task, and CSV vs. XLSX differences are handled ad hoc.

Desired behavior

A dedicated spreadsheet skill in ~/.hermes/skills/ that gives the agent a consistent, high-level vocabulary for spreadsheet operations:

read_sheet(path, sheet=None)         → structured JSON rows
write_sheet(path, rows, sheet=None)  → creates/overwrites sheet
apply_formula(path, cell, formula)   → sets a formula and recalculates
pivot(path, rows, cols, values, agg) → builds a pivot table
chart(path, type, data_range, title) → embeds a chart into the workbook
diff(path_a, path_b)                 → highlights cell-level changes

A CSV fallback path should handle plain CSVs without requiring Excel dependencies. This mirrors the pattern used by the existing pdf and browser skills.

Implementation sketch

• Core wrapper around openpyxl (read/write .xlsx with formatting preservation) + xlsxwriter (chart embedding, new workbook creation) + pandas (pivot tables, aggregation, CSV fallback).
• Skill manifest registers the above functions as tool-callable operations, matching the existing skill infrastructure.
• Formatting preservation: read_sheet → write_sheet round-trips should not destroy cell styles, merged cells, or conditional formatting. This is the main pain point with naive pandas usage.
• Error handling: clear messages for corrupt files, missing sheets, formula errors, and unsupported chart types.
• Dependencies: openpyxl, xlsxwriter, pandas added as optional extras (pip install hermes-agent[spreadsheet]).

Why this matters

Spreadsheets are the universal data format — finance, HR, operations, research. No other mainstream agent framework ships a first-class spreadsheet skill. This would be a strong differentiator and covers one of the most common real-world automation use cases.

Related issues

• [Feature]: skills create / skills edit should support writing to a configurable target directory #4381 — skills create / skills edit configurable target directory (the spreadsheet skill would benefit from the --dir flag and default_write_dir config proposed there)

[w2jiodsfa]

Product Review ✅

Reviewed PR #4442 (raphael-solace/feature/spreadsheet-skill).

Verdict: Ready to Merge

All 7 requirements from this issue are implemented:

• , , , , , — all present
• CSV/TSV fallback covered (no Excel dependencies required)
• Formatting preservation via openpyxl (not pandas)
• 38 unit tests, all passing CI

Minor items (non-blocking for v1.0.0):

• No explicit corrupt-file error handling
• No numeric data validation in chart script

Will close automatically when PR merges.

[PSU3D0]

I noticed this PR doesn't cover re-calculation. Formualizer is a robust spreadsheet engine that has python bindings:

// pip install formualizer==0.5.8
import formualizer as fz

# in-place
summary = fz.recalculate_file("financial_model.xlsx")
print(summary["status"], summary["evaluated"], summary["errors"])

# write to a new file
summary = fz.recalculate_file("financial_model.xlsx", output="financial_model.recalc.xlsx")

[Whatsonyourmind]

The hardest part of this skill — preserving formatting + formulas across read/write round-trips, and getting apply_formula → recalculate to actually work — is exactly where naive openpyxl use breaks down. A few specifics that may save a week of debugging:

1. Formula recalculation: openpyxl doesn't have a formula engine. Setting a formula stores the string but never computes the value. To actually recalculate, round-trip through headless LibreOffice (soffice --headless --calc --convert-to xlsx) — the only no-Excel-dependency way to get cell values populated after formula writes.
2. Formatting preservation on round-trip: pandas.read_excel → to_excel destroys styles, merged cells, and conditional formatting. Stay on raw openpyxl Workbook for round-trips; convert to DataFrame only at the leaves.
3. Pivot tables: openpyxl writes pivot definitions but can't create the cached aggregate. Excel/LibreOffice fill the cache on first open; for fully-rendered-without-open pivots, again the headless recalc step.
4. Charts: xlsxwriter writes cleanly but can't read+modify existing workbooks. openpyxl does both but its chart API is more verbose. Easiest split: new workbook → xlsxwriter; modify existing → openpyxl.

If a reference for the MCP-side skill shape is useful, I've shipped these exact primitives (read / write / formula / pivot / chart + 7-jurisdiction tax modules + DCF/LBO/3-statement templates) as an MCP server: https://github.com/Whatsonyourmind/modelforge / pip install modelforge-finance. Different scope than what you're building, but the openpyxl + LibreOffice recalc pattern + MCP tool surface may be reusable. Happy to dig into specifics if useful.

[gregkonush]

One additional option for the recalculation part: if the skill can call a stdio MCP server, Bilig WorkPaper gives the agent a workbook-shaped tool boundary instead of making it write openpyxl formula-handling code directly.

It is not a replacement for openpyxl / xlsxwriter formatting and chart work. The useful path is narrower:

• agent edits input cells
• server recalculates dependent formulas
• agent reads display values back
• server exports/persists the WorkPaper JSON

Smoke command:

npm exec --yes --package @bilig/workpaper@latest -- bilig-workpaper-mcp --workpaper ./pricing.workpaper.json --init-demo-workpaper --writable

The MCP tool surface includes list_sheets, read_range / read_cell, set_cell_contents, get_cell_display_value, validate_formula, and export_workpaper_document. It is also registered as io.github.proompteng/bilig-workpaper in the official MCP Registry, with a hosted Streamable HTTP endpoint at https://bilig.proompteng.ai/mcp for clients that prefer remote MCP.

For Hermes, I would probably keep the Python path for normal XLSX rendering, then add an optional MCP-backed formula/readback path for cases where stale cached formula results are the hard part.

Disclosure: I maintain Bilig, so treat this as a concrete option to test rather than a neutral recommendation.

[KeithCu]

Hello, I've built a LibreOffice plugin with MCP support and other features that could be useful: https://github.com/KeithCu/writeragent Do you want to try to use it? If you have any feature requests, I could work on them.

[GottZ]

This was generated by AI during triage.

Summary

One PR addresses #4438. #4442 adds a generic spreadsheet skill with six CLI helpers for XLSX/CSV/TSV reading, writing, formulas, pivots, charts, and cell-level diffs, but its implementation does not yet satisfy the issue’s formatting-preserving round-trip or formula-recalculation requirements.

Related pull requests

• feat(skills): add rich spreadsheet skill for xlsx/csv handling #4442 best fix — (+1349/-0) — partial fix, keep open for revision: the diff provides the requested helper surface, CSV/TSV fallback, XLSX operations, and tests, but write_sheet.py always creates a new workbook, apply_formula.py only stores formula strings without recalculation, advertised .xls files are incorrectly routed through openpyxl, and ranged reads still materialize the full worksheet. This agrees with the contributor keep_open review on feat(skills): add rich spreadsheet skill for xlsx/csv handling #4442; its blocking findings must be addressed before merge.

Suggested consolidation

Merge #4442 after revising it to preserve and modify existing workbook structure and formatting, implement an actual formula recalculation path, remove or correctly implement .xls support, and avoid full-sheet materialization for ranged reads. It is the sole and best-fix PR for #4438, so there are no duplicate PRs to close, but it should not be merged over the contributor keep_open review until those documented gaps are resolved.

Complex graph

flowchart LR
    classDef open fill:#dbeafe,stroke:#1d4ed8,color:#1e3a8a
    classDef merged fill:#dcfce7,stroke:#15803d,color:#14532d
    classDef closed fill:#e5e7eb,stroke:#6b7280,color:#1f2937
    classDef unverified fill:#f3f4f6,stroke:#9ca3af,color:#374151
    classDef best stroke-width:3px,stroke:#b45309
    classDef target stroke-width:3px,stroke:#4338ca
    I4438(["issue #4438 (open)"])
    P4442["PR #4442 (open)"]
    P4442 -->|best fix| I4438
    class I4438 open
    class I4438 target
    class P4442 open
    class P4442 best
    click I4438 "https://github.com/NousResearch/hermes-agent/issues/4438"
    click P4442 "https://github.com/NousResearch/hermes-agent/pull/4442"

Loading

Graph: solid arrow = fixes / best fix, dashed arrow = partial or unverified (see edge label); boxed group = PRs duplicating each other; amber border = best fix; indigo border = target; gray node = closed or no verify verdict yet (state tag in the node label).

Cross-PR triage: Reviewed 1 pull request and 1 issue in this complex. Each diff was read against this issue; Assessment working set: 46 kB of PR diffs, 4 kB of issue/PR text, 6 kB of discussion (8 comments), 2 verify verdicts. verdicts reflect diff content, not PR titles. Part of an automated triage batch.

[njaremko]

This is admittedly partially an advertisement, since I wrote it, but I think it's useful here, so I'll share it.

My team and I have implemented (to my knowledge) the only bug-for-bug, bit-perfect math, calculation engine for xlsx files. You can make whatever change you want to any excel file, and we'll recalculate it exactly how Excel would recalculate it. We ship a GUI and a CLI at our website, but if you're using hermes you're probably more interested in the CLI (though if you have the GUI, you can watch it build the spreadsheets while it uses the CLI).

If you only want the CLI npm install -g @nobie-org/nobie and telling the agent to use nobie will get you a really good tool and bundled skill for doing everything you could ever want in an xlsx file (making charts, conditional formatting, data tables, printing to PDF (exactly how excel would), rendering ranges to PNG (exactly how excel would), etc)

[adi-prasada]

Heavy +1 on this feature. Working with large-scale corporate operational spreadsheets (10k+ rows, 16k+ columns, multi-tab KPIs) constantly faces formatting destruction when round-tripping through naive or raw . Having a first-class skill with native , (style-preserving), , and operations will hugely improve real-world data analyst workflows in Hermes.