@rich-apis/cursorrules 1.0.0

package/README.md

@@ -0,0 +1,83 @@
+# @rich-apis/cursorrules
+
+Professional `.cursorrules` templates for [Cursor AI](https://cursor.sh). One command to set up battle-tested AI coding rules for your project.
+
+More templates and vibe coding tips: **[t.me/vibecodingtips_original](https://t.me/vibecodingtips_original)**
+
+## Quick Start
+
+```bash
+# Copy a template to your project
+npx @rich-apis/cursorrules init nextjs
+npx @rich-apis/cursorrules init fastapi
+npx @rich-apis/cursorrules init react-native
+```
+
+That's it. Open your project in Cursor and the rules are active.
+
+## Available Templates
+
+| Template | Stack | Highlights |
+|----------|-------|------------|
+| `nextjs` | Next.js 14+, TypeScript, Tailwind | App Router, Server Components, Server Actions, Zod validation |
+| `fastapi` | Python 3.11+, FastAPI, Pydantic v2 | 3-layer architecture, async, SQLAlchemy 2.0, Alembic |
+| `react-native` | React Native / Expo, TypeScript | React Navigation, Zustand, React Query, FlashList |
+
+## What's Inside
+
+Each template defines:
+
+- **Tech stack** expectations so the AI uses the right libraries
+- **Code style** rules (naming, structure, patterns)
+- **Architecture** guidelines (where logic lives, layering)
+- **Performance** best practices specific to the framework
+- **Security** rules the AI must follow
+- **Testing** expectations and patterns
+
+## CLI Usage
+
+```bash
+# List all templates
+npx @rich-apis/cursorrules list
+
+# Initialize a template
+npx @rich-apis/cursorrules init <template>
+
+# Help
+npx @rich-apis/cursorrules --help
+```
+
+## Programmatic Usage
+
+```js
+const { getTemplate, listTemplates } = require('@rich-apis/cursorrules');
+
+// Get template content
+const rules = getTemplate('nextjs');
+
+// List available templates
+const templates = listTemplates();
+// [{ id: 'nextjs', name: 'Next.js', description: '...' }, ...]
+```
+
+## Customization
+
+The templates are starting points. After running `init`, edit `.cursorrules` to match your project:
+
+- Add your specific libraries and versions
+- Adjust architecture rules to your codebase
+- Add project-specific conventions
+- Include domain terminology
+
+## Why .cursorrules?
+
+Cursor AI reads `.cursorrules` from your project root to understand your coding standards. Without rules, the AI guesses. With good rules, it writes code that fits your codebase from the first try.
+
+## More Resources
+
+- **[Vibe Coding Tips](https://t.me/vibecodingtips_original)** - Telegram channel with daily AI coding tips
+- **[Cursor Docs](https://docs.cursor.com)** - Official Cursor documentation
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const TEMPLATES = {
+  nextjs: 'nextjs.cursorrules',
+  fastapi: 'fastapi.cursorrules',
+  'react-native': 'react-native.cursorrules',
+};
+
+const TEMPLATE_DIR = path.join(__dirname, '..', 'templates');
+
+function showHelp() {
+  console.log(`
+@rich-apis/cursorrules - Professional .cursorrules templates
+
+Usage:
+  npx @rich-apis/cursorrules init [template]    Copy a template to your project
+  npx @rich-apis/cursorrules list               List available templates
+
+Templates:
+  nextjs          Next.js 14+ (App Router, TypeScript, Tailwind)
+  fastapi         FastAPI (Python, Pydantic v2, SQLAlchemy)
+  react-native    React Native / Expo (TypeScript, React Navigation)
+
+Examples:
+  npx @rich-apis/cursorrules init nextjs
+  npx @rich-apis/cursorrules init fastapi
+  npx @rich-apis/cursorrules list
+
+More templates and tips: https://t.me/vibecodingtips_original
+`);
+}
+
+function listTemplates() {
+  console.log('\nAvailable .cursorrules templates:\n');
+  for (const [name, file] of Object.entries(TEMPLATES)) {
+    const content = fs.readFileSync(path.join(TEMPLATE_DIR, file), 'utf8');
+    const firstLine = content.split('\n').find(l => l.startsWith('#'));
+    const desc = firstLine ? firstLine.replace(/^#\s*/, '') : name;
+    console.log(`  ${name.padEnd(16)} ${desc}`);
+  }
+  console.log('\nUsage: npx @rich-apis/cursorrules init <template>');
+  console.log('More templates: https://t.me/vibecodingtips_original\n');
+}
+
+function initTemplate(templateName) {
+  if (!templateName) {
+    console.error('Error: Please specify a template name.');
+    console.log('Available templates: ' + Object.keys(TEMPLATES).join(', '));
+    console.log('Usage: npx @rich-apis/cursorrules init <template>');
+    process.exit(1);
+  }
+
+  const normalized = templateName.toLowerCase().trim();
+
+  if (!TEMPLATES[normalized]) {
+    console.error(`Error: Unknown template "${templateName}".`);
+    console.log('Available templates: ' + Object.keys(TEMPLATES).join(', '));
+    process.exit(1);
+  }
+
+  const src = path.join(TEMPLATE_DIR, TEMPLATES[normalized]);
+  const dest = path.join(process.cwd(), '.cursorrules');
+
+  if (fs.existsSync(dest)) {
+    console.log('Warning: .cursorrules already exists in this directory.');
+    console.log('Overwriting with the ' + normalized + ' template...');
+  }
+
+  try {
+    fs.copyFileSync(src, dest);
+    console.log(`\n  Created .cursorrules (${normalized} template)\n`);
+    console.log('  Open your project in Cursor and the rules will be active.');
+    console.log('  Customize the rules to match your specific project.\n');
+    console.log('  More templates & tips: https://t.me/vibecodingtips_original');
+    console.log('');
+  } catch (err) {
+    console.error('Error writing .cursorrules:', err.message);
+    process.exit(1);
+  }
+}
+
+// Parse arguments
+const args = process.argv.slice(2);
+const command = args[0];
+
+switch (command) {
+  case 'init':
+    initTemplate(args[1]);
+    break;
+  case 'list':
+    listTemplates();
+    break;
+  case '--help':
+  case '-h':
+  case 'help':
+    showHelp();
+    break;
+  default:
+    if (!command) {
+      showHelp();
+    } else {
+      console.error(`Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+    }
+}

package/index.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * @rich-apis/cursorrules
+ * Professional .cursorrules templates for Cursor AI.
+ *
+ * CLI usage: npx @rich-apis/cursorrules init <template>
+ *
+ * Programmatic usage:
+ *   const { getTemplate, listTemplates } = require('@rich-apis/cursorrules');
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const TEMPLATE_DIR = path.join(__dirname, 'templates');
+
+const TEMPLATES = {
+  nextjs: {
+    file: 'nextjs.cursorrules',
+    name: 'Next.js',
+    description: 'Next.js 14+ with App Router, TypeScript, and Tailwind CSS',
+  },
+  fastapi: {
+    file: 'fastapi.cursorrules',
+    name: 'FastAPI',
+    description: 'FastAPI with Pydantic v2, SQLAlchemy 2.0, and async support',
+  },
+  'react-native': {
+    file: 'react-native.cursorrules',
+    name: 'React Native',
+    description: 'React Native / Expo with TypeScript and React Navigation',
+  },
+};
+
+/**
+ * Get the content of a template.
+ * @param {string} name - Template name: "nextjs", "fastapi", or "react-native"
+ * @returns {string} Template content
+ * @throws {Error} If template name is unknown
+ */
+function getTemplate(name) {
+  const template = TEMPLATES[name];
+  if (!template) {
+    throw new Error(`Unknown template: "${name}". Available: ${Object.keys(TEMPLATES).join(', ')}`);
+  }
+  return fs.readFileSync(path.join(TEMPLATE_DIR, template.file), 'utf8');
+}
+
+/**
+ * List available templates.
+ * @returns {Array<{ id: string, name: string, description: string }>}
+ */
+function listTemplates() {
+  return Object.entries(TEMPLATES).map(([id, info]) => ({
+    id,
+    name: info.name,
+    description: info.description,
+  }));
+}
+
+module.exports = {
+  getTemplate,
+  listTemplates,
+  TEMPLATES: Object.keys(TEMPLATES),
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@rich-apis/cursorrules",
+  "version": "1.0.0",
+  "description": "Professional .cursorrules templates for Next.js, FastAPI, and React Native projects",
+  "main": "index.js",
+  "bin": {
+    "cursorrules": "bin/cli.js"
+  },
+  "files": [
+    "index.js",
+    "bin/",
+    "templates/"
+  ],
+  "keywords": [
+    "cursorrules",
+    "cursor",
+    "cursor rules",
+    "ai coding",
+    "vibe coding",
+    "cursor ide",
+    "cursor editor",
+    "nextjs",
+    "fastapi",
+    "react native",
+    "ai rules",
+    "coding assistant",
+    "cursor ai"
+  ],
+  "author": "Rich APIs <npm@rich-apis.store>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/den-maxi/cursorrules"
+  },
+  "homepage": "https://github.com/den-maxi/cursorrules#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/templates/fastapi.cursorrules

@@ -0,0 +1,88 @@
+# FastAPI Project Rules for Cursor AI
+
+You are an expert Python/FastAPI developer building a production API.
+
+## Tech Stack
+- Python 3.11+
+- FastAPI with Pydantic v2
+- SQLAlchemy 2.0 (async) or Tortoise ORM
+- Alembic for migrations
+- pytest for testing
+- Redis for caching (optional)
+
+## Code Style
+- Follow PEP 8 strictly
+- Use type hints on all function signatures and variables
+- Use `async def` for all route handlers
+- Docstrings on all public functions (Google style)
+- Maximum line length: 100 characters
+- Use pathlib over os.path
+
+## Project Structure
+```
+app/
+  api/
+    v1/
+      endpoints/     # Route handlers grouped by domain
+      dependencies.py
+  core/
+    config.py        # Settings with pydantic-settings
+    security.py      # Auth helpers
+  models/            # SQLAlchemy models
+  schemas/           # Pydantic request/response schemas
+  services/          # Business logic layer
+  repositories/      # Data access layer
+  main.py
+tests/
+  conftest.py
+  api/
+  services/
+```
+
+## Architecture Rules
+- 3-layer architecture: routes -> services -> repositories
+- Routes handle HTTP concerns only (status codes, headers)
+- Services contain business logic, never import FastAPI directly
+- Repositories handle database queries only
+- Use dependency injection via `Depends()` for everything
+- Never put business logic in route handlers
+
+## Pydantic Schemas
+- Separate schemas for Create, Update, and Response
+- Use `model_config = ConfigDict(from_attributes=True)` for ORM models
+- Validate all inputs with Pydantic — never trust raw request data
+- Use `Field()` with descriptions for auto-generated docs
+
+## Error Handling
+- Define custom exception classes for business errors
+- Register exception handlers in main.py
+- Always return structured error responses: `{"detail": "...", "code": "..."}`
+- Use proper HTTP status codes (don't use 200 for errors)
+
+## Security
+- Use OAuth2 with JWT tokens
+- Hash passwords with bcrypt via passlib
+- Validate and sanitize all inputs
+- Rate limit endpoints with slowapi
+- CORS configuration: explicit allowed origins, never wildcard in production
+- Never log sensitive data
+
+## Database
+- Use async sessions for all database operations
+- Always use transactions for multi-step operations
+- Index frequently queried columns
+- Use `select_in_loading` to avoid N+1 queries
+- Write Alembic migrations for every schema change
+
+## Testing
+- Use pytest with pytest-asyncio
+- Create fixtures for database sessions, authenticated clients
+- Test happy path AND error cases for every endpoint
+- Use factories (factory_boy) for test data
+- Target 80%+ test coverage
+
+## Responses
+- Explain reasoning before code
+- Suggest performance improvements when relevant
+- Flag potential security issues proactively
+- Consider backward compatibility when changing API contracts

package/templates/nextjs.cursorrules

@@ -0,0 +1,58 @@
+# Next.js Project Rules for Cursor AI
+
+You are an expert Next.js developer working on a production application.
+
+## Tech Stack
+- Next.js 14+ (App Router)
+- TypeScript (strict mode)
+- Tailwind CSS for styling
+- Prisma or Drizzle for database
+- NextAuth.js or Clerk for authentication
+
+## Code Style
+- Use functional components exclusively
+- Prefer Server Components by default; use 'use client' only when necessary
+- Use named exports for components, default exports only for pages
+- Colocate related files: component, styles, tests, types in the same directory
+- File naming: kebab-case for files, PascalCase for components
+
+## Architecture Rules
+- Keep Server Actions in separate files (actions.ts)
+- Validate all inputs with Zod schemas
+- Use the `unstable_cache` or `React.cache` for data fetching deduplication
+- Handle loading states with loading.tsx and Suspense boundaries
+- Handle errors with error.tsx boundaries
+- Never expose server-only code to the client
+
+## TypeScript
+- No `any` types — use `unknown` and narrow with type guards
+- Define interfaces for all component props
+- Use discriminated unions for state management
+- Use `satisfies` operator for type-safe object literals
+- Infer types from Zod schemas where possible
+
+## Performance
+- Use `next/image` for all images with explicit width/height
+- Use `next/font` for font loading
+- Implement proper metadata exports for SEO
+- Use dynamic imports for heavy client components
+- Implement ISR or SSG where data allows
+
+## Testing
+- Write unit tests with Vitest
+- Use Testing Library for component tests
+- Test Server Actions independently
+- Mock external services in tests
+
+## Security
+- Validate and sanitize all user inputs
+- Use parameterized queries (never raw SQL)
+- Implement rate limiting on API routes
+- Set proper CORS headers
+- Never commit .env files
+
+## Responses
+- Explain your reasoning briefly before writing code
+- If a task is ambiguous, ask for clarification
+- Suggest simpler alternatives when the requested approach is over-engineered
+- Always consider edge cases and error states

package/templates/react-native.cursorrules

@@ -0,0 +1,89 @@
+# React Native Project Rules for Cursor AI
+
+You are an expert React Native developer building a production mobile application.
+
+## Tech Stack
+- React Native 0.73+ (or Expo SDK 50+)
+- TypeScript (strict mode)
+- React Navigation v6 for routing
+- Zustand or Jotai for state management
+- React Query (TanStack Query) for server state
+- Nativewind or StyleSheet for styling
+
+## Code Style
+- Functional components only — no class components
+- Use named exports for all components
+- File naming: kebab-case for files, PascalCase for components
+- One component per file (except small helper components)
+- Colocate styles at the bottom of the component file
+- Prefix hooks with `use`, utilities with their domain
+
+## Project Structure
+```
+src/
+  app/              # Navigation setup, providers
+  screens/          # Screen components (one per route)
+  components/
+    ui/             # Generic reusable components (Button, Input, Card)
+    domain/         # Business-specific components
+  hooks/            # Custom hooks
+  services/         # API clients, external service wrappers
+  stores/           # Zustand stores
+  utils/            # Pure utility functions
+  types/            # Shared TypeScript types
+  constants/        # App-wide constants
+  assets/           # Images, fonts, etc.
+```
+
+## Architecture Rules
+- Screens orchestrate, components render
+- Keep screens thin: delegate logic to hooks and services
+- All API calls go through services/ — never fetch in components directly
+- Use React Query for all server state (caching, refetching, optimistic updates)
+- Use Zustand only for client-side state (theme, auth token, preferences)
+- Never use `any` type
+
+## Performance
+- Use `React.memo` for list item components
+- Use `useCallback` for functions passed to child components
+- Use `useMemo` for expensive computations
+- Use `FlashList` instead of `FlatList` for long lists
+- Optimize images: use WebP, proper sizing, and caching
+- Avoid unnecessary re-renders — profile with React DevTools
+- Use `InteractionManager.runAfterInteractions` for heavy post-navigation work
+
+## Navigation
+- Type all navigation params with TypeScript
+- Use deep linking configuration from the start
+- Handle back button behavior explicitly on Android
+- Lazy load screens with `React.lazy` or navigation lazy loading
+
+## Platform Handling
+- Use `Platform.select` or `.ios.tsx`/`.android.tsx` for platform differences
+- Test on both iOS and Android simulators
+- Handle safe areas with `react-native-safe-area-context`
+- Handle keyboard avoidance properly (KeyboardAvoidingView)
+
+## Error Handling
+- Wrap screens in Error Boundaries
+- Handle network errors gracefully — show retry options
+- Use React Query's error states for API failures
+- Log errors to a crash reporting service (Sentry, Bugsnag)
+
+## Testing
+- Unit test hooks and utilities with Jest
+- Component test with React Native Testing Library
+- Test navigation flows
+- Test on real devices before release
+
+## Accessibility
+- Add `accessibilityLabel` to all interactive elements
+- Support Dynamic Type / font scaling
+- Ensure touch targets are at least 44x44 points
+- Test with VoiceOver (iOS) and TalkBack (Android)
+
+## Responses
+- Always consider both iOS and Android behavior
+- Mention if a solution requires native module linking
+- Flag potential performance issues with large lists or heavy renders
+- Suggest Expo alternatives when using bare React Native