Cursor Rules Template: AI Sales Call Analysis with Cursor Rules

Overview


Cursor rules configuration helps Cursor AI guide a Node.js/TypeScript backend to build AI sales call analysis apps that extract objections and buying signals from transcripts. This Cursor Rules Template targets a stack using Express or NestJS, PostgreSQL, and the OpenAI API to process call data.


When to Use These Cursor Rules



- When building a back-end service that ingests transcripts and produces structured objections and buying signals.

- When you need consistent prompts and safer AI outputs across multiple calls and agents.

- When you want a repeatable project layout and strong typing for reliability.


Copyable .cursorrules Configuration


Framework Role & Context:
- Node.js + TypeScript backend with Express or NestJS
- PostgreSQL as the primary data store; OpenAI API for analysis

Code Style and Style Guides:
- ESLint + Prettier; strict TypeScript; no implicit any

Architecture & Directory Rules:
- src/controllers, src/services, src/models, src/database, src/middleware, src/routes
- Clear separation of concerns and dependency injection patterns

Authentication & Security Rules:
- JWT Bearer tokens; HTTPS; env-based secrets; rotate keys

Database and ORM patterns:
- PostgreSQL via node-postgres pg; parameterized queries; no string-concat SQL
- Use a thin repository layer between services and queries

Testing & Linting Workflows:
- Vitest unit tests; integration tests; ESLint + Prettier in CI

Prohibited Actions and Anti-patterns for the AI:
- Do not log full transcripts; redact PII in logs
- Do not bypass authentication or leak secrets
- Do not perform destructive data migrations in prompts
Recommended Project Structure


my-app/
├── src/
│   ├── controllers/
│   │   └── callAnalysisController.ts
│   ├── services/
│   │   └── analysisService.ts
│   ├── models/
│   │   └── transcript.ts
│   ├── database/
│   │   └── pgClient.ts
│   ├── routes/
│   │   └── analysisRoutes.ts
│   ├── middleware/
│   │   └── authMiddleware.ts
│   ├── config/
│   │   └── envConfig.ts
│   └── tests/
│       └── analysis.test.ts
├── tests/
├── .env.example
├── package.json
├── tsconfig.json
Core Engineering Principles



- Clear data flow from transcripts to signals; idempotent processing.

- Strong typing and contracts between layers.

- Observability with structured logging and metrics for analysis results.

- Privacy by design; minimize PII exposure and audit access.

- Deterministic prompts and guardrails for safe AI-assisted development.


Code Construction Rules



- Define precise TypeScript interfaces for Transcript, Objection, and BuyingSignal.

- Use parameterized SQL via node-postgres pg; avoid string concatenation.

- Prompts must explicitly instruct extraction of objections and buying signals.

- Keep concerns separated: controllers for routing, services for logic, models for data.

- Caching for expensive OpenAI calls with short TTL.

- Do not embed secrets in source code; read from environment vars.


Security and Production Rules



- Enforce TLS, rotate credentials, and store secrets in a vault or env vars.

- Validate and sanitize transcript inputs; enforce size and content constraints.

- Rate-limit requests; use per-client API keys; monitor for abuse.

- Do not log raw transcripts; redact PII and sensitive data in logs.


Testing Checklist



- Unit tests for parsing transcripts into objections and buying signals.

- Integration tests from ingestion to stored insights.

- CI checks for linting, type checks, and test suite; optional end-to-end tests.


Common Mistakes to Avoid



- Skipping input validation and relying on client data.

- Using unsafe prompts without clear guardrails or fail-safes.

- Neglecting data privacy and logging PII in production logs.

- Assuming a single prompt works across languages and transcription styles.



Related implementation resources: AI Agent Use Case for Call Centers Using Conversation Transcripts to Monitor Service Quality.




FAQ


What is Cursor Rules Template?


A Cursor Rules Template is a ready-to-paste .cursorrules configuration tailored for building AI sales call analysis apps. It codifies the stack roles, directory layout, and safety constraints so developers can quickly deploy Cursor AI-driven analysis for objections and buying signals.


Which stack does this template cover?


This template targets Node.js with TypeScript, Express or NestJS, PostgreSQL, and the OpenAI API to analyze call transcripts and extract sales objections and buying signals.


How do I customize the .cursorrules block?


Modify framework roles, directory paths, and prompts to reflect your project’s architecture, while preserving the safety constraints and anti-patterns that protect your data and users.


Can I reuse this in multi-tenant environments?


Yes, adapt the authentication and data access rules to tenant boundaries, and ensure per-tenant metadata is stored separately while sharing the analysis logic.


What should I validate in production?


Validate prompt correctness, latency budgets, and data privacy; monitor error rates from the AI engine and ensure secure handling of transcripts and signals.