Cursor Rules Template: Board Report Generators from Finance Spreadsheets

Overview

Direct answer: This Cursor Rules Template provides concrete, copyable Cursor AI instructions to build board report generators from finance spreadsheets and management reports using a Node.js/TypeScript stack. It ensures deterministic parsing, transformation, and narration for board packs.

When to Use These Cursor Rules

When you need to convert finance spreadsheets (.xlsx, .csv) and management reports into standardized board-ready outputs.
When you require consistent data mapping and auditable transformations across sources.
When you want to enforce security, validation, and deterministic results in a recurrent reporting workflow.

Copyable .cursorrules Configuration

.cursorrules
frameworkRole: 'Node.js + TypeScript stack for board report generation'
context: 'Parse finance spreadsheets and management reports, output structured board data and narrative'
codeStyle: 'TypeScript strict, ESLint, Prettier'
architecture: 'src/, parsers/, boardReports/, services/, db/, tests/'
authSecurity: 'Token-based API access; do not log PII; secrets from env vars'
database: 'PostgreSQL via pg; use parameterized queries; avoid ORMs'
testingLinting: 'Jest for unit/integration tests; ESLint/TSLint; run npm test and npm run lint'
antiPatterns: 'Do not mutate original input; do not execute in production against live data without explicit gating'

Recommended Project Structure

project-root/
├─ src/
│  ├─ parsers/
│  │  └─ finance.ts
│  ├─ boardReports/
│  │  ├─ generator.ts
│  │  └─ templates/
│  │     └─ index.ts
│  ├─ db/
│  │  └─ migrations/
│  ├─ tests/
│  │  ├─ unit/
│  │  └─ integration/
│  └─ index.ts
├─ migrations/
├─ .eslintrc.js
├─ package.json

Core Engineering Principles

Deterministic data processing with explicit inputs and outputs.
Idempotent operations and safe retries in data pipelines.
Clear separation of concerns: parsing, transformation, storage, and presentation.
Type safety and linting enforced by TypeScript and ESLint.
Observability: structured logs, metrics, and tracing for auditability.

Code Construction Rules

Prefer explicit types; do not use dynamic typing in critical data paths.
Parse spreadsheets with streaming parsers to avoid high memory usage.
Validate all inputs (sources, schemas) before transforming data.
Output board data in predictable structures with explicit field names.
Do not use unsafe eval or runtime code generation.
Follow the Architecture & Directory Rules to keep code modular and navigable.

Security and Production Rules

Mask sensitive data; never log PII; store secrets in environment variables.
Enforce RBAC for data access; use short-lived tokens for API calls.
Run in isolated environments; separate staging and production data.
Encrypt data at rest and in transit where applicable.

Testing Checklist

Unit tests for parsers and transformation helpers.
Integration tests for end-to-end data flow from spreadsheet to board output.
End-to-end tests with a fake dataset representing finance and management reports.
CI/CD: linting, type checking, and automated tests on pull requests.

Common Mistakes to Avoid

Relying on brittle parsers that fail on slightly different spreadsheet formats.
Skipping input validation leading to inconsistent board outputs.
Logging sensitive data; failing to mask PII.
Ignoring versioning for the board report templates and outputs.

FAQ

What is this Cursor Rules Template for board report generators?

This template provides a concrete, copyable set of Cursor AI rules to transform finance spreadsheets and management reports into structured board-ready outputs using a Node.js/TypeScript stack and PostgreSQL backend.

Which stack components are covered by this template?

The template covers Node.js with TypeScript, Excel/CSV parsing for finance data, a PostgreSQL database via pg, a simple generator module, ESLint/TypeScript linting, and Jest tests for unit and integration checks.

How do I integrate the rules into my project?

Copy the .cursorrules block into your project root as .cursorrules, then ensure your codebase provides the modules and paths described in the Architecture & Directory Rules section. Adjust environment vars for data access in production.

What are the security considerations?

Mask PII, restrict data access by tokens, avoid logging sensitive data, and run in isolated environments with proper RBAC to protect board data.

How is testing approached?

Unit tests for parsers, integration tests for end-to-end data flows, and CI/CD with linting and type checks ensure reliability in production workflows.

Target User

Use Cases