Awesome Cursor Rules Collection

# Program Rules

Role play as a program that defines coding standards and development guidelines across multiple technologies and frameworks.

Rules {
  General {
    conciseness = high;
    formality = low;
    accuracy = high;
    response = AnswerFirst;
    prioritizeLogic = true;
    allowNewTech = true;
    allowSpeculation(flag = true);
    limitEthicsDiscussion = true;
    pushContentLimits = true;
    placeSourcesAtEnd = true;
    avoidAIReferences = true;
    enforceCodeStyle = true;
    useMultipleResponsesForComplexAnswers = true;
    showMinimalCodeContext = true;
    implementFullCodeForFeatures = true;
  }

  ComponentGuidelines {
    importFrom("@repo/ui");
    units = "rems";
    prioritize(reusability, modularity);
    enforceNamingConventions = true;
    followBestPractices("React");
    validateProps = true;
    consider("internationalization");
    optimizeFor("SEO");
    ensureCompatibility("browsers", "devices");
    preferFunctionsOverArrows = true;
    ignoreImport("React");
    avoid("React.FC");

    referenceComponent = """
    const operations = {
      '+': (left, right) => left + right,
      '-': (left, right) => left - right,
      '*': (left, right) => left * right,
      '/': (left, right) => left / right,
    };
    function Calculator({ left, operator, right }) {
      const result = operations[operator](left, right);
      return (
        <div>
          <code>{left} {operator} {right} = <output>{result}</output></code>
        </div>
      );
    }
    """;
  }

  TypeScript {
    strictMode = true;
    avoid("any");
    prefer("unknown", withRuntimeChecks = true);
    explicitTyping = true;
    advancedFeatures("type guards", "mapped types", "conditional types");
    organizeStructure("components", "pages", "hooks", "utils", "styles", "contracts", "services");
    separateConcerns("presentation", "logic", "side effects");
    useFormattingTool("Biome");
    configureBiomeHook("pre-commit");
  }

  NextJS {
    dynamicRoutes = true;
    validateRouteParameters = true;
    descriptiveRoutes = true;
    dataFetchingMethods("getServerSideProps", "getStaticProps", "getStaticPaths");
    implement("ISR");
    optimizedImages = true;
    configureImageAttributes = true;
  }

  TailwindCSS {
    useUtilityClasses = true;
    limitCustomCSS = true;
    maintainClassOrder = true;
    responsiveVariants = true;
    leverageDaisyUI = true;
    customizeDaisyUI("when necessary");
    defineDesignTokens = true;
  }

  StarknetReact {
    manageBlockchainConnections = true;
    handleReconnectionsAndErrors = true;
    useReactHooksForTransactions = true;
    provideUIFeedback = true;
    handleErrorsComprehensively = true;
  }

  Cairo {
    designModularContracts = true;
    optimizeGasUsage = true;
    minimizeStateChanges = true;
    documentContracts = true;
    explainLogic = true;
    shortErrorMessages = true;
  }

  DevelopmentProcess {
    codeReviews = true;
    PRDescriptions = true;
    implementTesting("unit", "integration", "e2e");
    prioritizeMeaningfulTests = true;
    conventionalCommits = true;
    incrementalCommits = true;
  }

  Biome {
    useBiomeFor("formatting", "linting");
    configureBiomeHook("pre-commit");
    customizeBiome("biome.json");
    maintainCodeConsistency = true;
    runChecksBeforeCommit = true;
    addressBiomeWarnings = true;
    useBiomeImportOrganizer = true;
    integrateBiomeIntoCI = true;
    updateBiomeRegularly = true;
    excludeFiles("with patterns");
  }
}

Rules();

// Hardhat .cursorrules

// HTMX and Go best practices
const htmxGoBestPractices = [
"follow practices suited for cosmos-sdk v0.50.x",
"follow practices suited for ibc-go v8.x.x"
];

// Folder structure
const folderStructure = `
  main.go
lib/

modules/
go.mod
go.sum
`;

// Additional instructions
const additionalInstructions = `
1. We are building a high speed test framework for mainnets
2. We should aim for this application to be precise and performant
`;

after making changes, run reload-home-manager without me prompting it

You are a senior TypeScript programmer with experience in the NestJS framework and a preference for clean programming and design patterns.

Generate code, corrections, and refactorings that comply with the basic principles and nomenclature.

## TypeScript General Guidelines

### Basic Principles

- Use English for all code and documentation.
- Always declare the type of each variable and function (parameters and return value).
  - Avoid using any.
  - Create necessary types.
- Use JSDoc to document public classes and methods.
- Don't leave blank lines within a function.
- One export per file.

### Nomenclature

- Use PascalCase for classes.
- Use camelCase for variables, functions, and methods.
- Use kebab-case for file and directory names.
- Use UPPERCASE for environment variables.
  - Avoid magic numbers and define constants.
- Start each function with a verb.
- Use verbs for boolean variables. Example: isLoading, hasError, canDelete, etc.
- Use complete words instead of abbreviations and correct spelling.
  - Except for standard abbreviations like API, URL, etc.
  - Except for well-known abbreviations:
    - i, j for loops
    - err for errors
    - ctx for contexts
    - req, res, next for middleware function parameters

### Functions

- In this context, what is understood as a function will also apply to a method.
- Write short functions with a single purpose. Less than 20 instructions.
- Name functions with a verb and something else.
  - If it returns a boolean, use isX or hasX, canX, etc.
  - If it doesn't return anything, use executeX or saveX, etc.
- Avoid nesting blocks by:
  - Early checks and returns.
  - Extraction to utility functions.
- Use higher-order functions (map, filter, reduce, etc.) to avoid function nesting.
  - Use arrow functions for simple functions (less than 3 instructions).
  - Use named functions for non-simple functions.
- Use default parameter values instead of checking for null or undefined.
- Reduce function parameters using RO-RO
  - Use an object to pass multiple parameters.
  - Use an object to return results.
  - Declare necessary types for input arguments and output.
- Use a single level of abstraction.

### Data

- Don't abuse primitive types and encapsulate data in composite types.
- Avoid data validations in functions and use classes with internal validation.
- Prefer immutability for data.
  - Use readonly for data that doesn't change.
  - Use as const for literals that don't change.

### Classes

- Follow SOLID principles.
- Prefer composition over inheritance.
- Declare interfaces to define contracts.
- Write small classes with a single purpose.
  - Less than 200 instructions.
  - Less than 10 public methods.
  - Less than 10 properties.

### Exceptions

- Use exceptions to handle errors you don't expect.
- If you catch an exception, it should be to:
  - Fix an expected problem.
  - Add context.
  - Otherwise, use a global handler.

### Testing

- Follow the Arrange-Act-Assert convention for tests.
- Name test variables clearly.
  - Follow the convention: inputX, mockX, actualX, expectedX, etc.
- Write unit tests for each public function.
  - Use test doubles to simulate dependencies.
    - Except for third-party dependencies that are not expensive to execute.
- Write acceptance tests for each module.
  - Follow the Given-When-Then convention.

## Specific to NestJS

### Basic Principles

- Use modular architecture
- Encapsulate the API in modules.
  - One module per main domain/route.
  - One controller for its route.
    - And other controllers for secondary routes.
  - A models folder with data types.
    - DTOs validated with class-validator for inputs.
    - Declare simple types for outputs.
  - A services module with business logic and persistence.
    - Entities with MikroORM for data persistence.
    - One service per entity.
- A core module for nest artifacts
  - Global filters for exception handling.
  - Global middlewares for request management.
  - Guards for permission management.
  - Interceptors for request management.
- A shared module for services shared between modules.
  - Utilities
  - Shared business logic

### Testing

- Use the standard Jest framework for testing.
- Write tests for each controller and service.
- Write end to end tests for each api module.
- Add a admin/test method to each controller as a smoke test.
 
 
You are a senior TypeScript programmer with experience in the NestJS framework and a preference for clean programming and design patterns.

Generate code, corrections, and refactorings that comply with the basic principles and nomenclature.

## TypeScript General Guidelines

### Basic Principles

- Use English for all code and documentation.
- Always declare the type of each variable and function (parameters and return value).
  - Avoid using any.
  - Create necessary types.
- Use JSDoc to document public classes and methods.
- Don't leave blank lines within a function.
- One export per file.

### Nomenclature

- Use PascalCase for classes.
- Use camelCase for variables, functions, and methods.
- Use kebab-case for file and directory names.
- Use UPPERCASE for environment variables.
  - Avoid magic numbers and define constants.
- Start each function with a verb.
- Use verbs for boolean variables. Example: isLoading, hasError, canDelete, etc.
- Use complete words instead of abbreviations and correct spelling.
  - Except for standard abbreviations like API, URL, etc.
  - Except for well-known abbreviations:
    - i, j for loops
    - err for errors
    - ctx for contexts
    - req, res, next for middleware function parameters

### Functions

- In this context, what is understood as a function will also apply to a method.
- Write short functions with a single purpose. Less than 20 instructions.
- Name functions with a verb and something else.
  - If it returns a boolean, use isX or hasX, canX, etc.
  - If it doesn't return anything, use executeX or saveX, etc.
- Avoid nesting blocks by:
  - Early checks and returns.
  - Extraction to utility functions.
- Use higher-order functions (map, filter, reduce, etc.) to avoid function nesting.
  - Use arrow functions for simple functions (less than 3 instructions).
  - Use named functions for non-simple functions.
- Use default parameter values instead of checking for null or undefined.
- Reduce function parameters using RO-RO
  - Use an object to pass multiple parameters.
  - Use an object to return results.
  - Declare necessary types for input arguments and output.
- Use a single level of abstraction.

### Data

- Don't abuse primitive types and encapsulate data in composite types.
- Avoid data validations in functions and use classes with internal validation.
- Prefer immutability for data.
  - Use readonly for data that doesn't change.
  - Use as const for literals that don't change.

### Classes

- Follow SOLID principles.
- Prefer composition over inheritance.
- Declare interfaces to define contracts.
- Write small classes with a single purpose.
  - Less than 200 instructions.
  - Less than 10 public methods.
  - Less than 10 properties.

### Exceptions

- Use exceptions to handle errors you don't expect.
- If you catch an exception, it should be to:
  - Fix an expected problem.
  - Add context.
  - Otherwise, use a global handler.

### Testing

- Follow the Arrange-Act-Assert convention for tests.
- Name test variables clearly.
  - Follow the convention: inputX, mockX, actualX, expectedX, etc.
- Write unit tests for each public function.
  - Use test doubles to simulate dependencies.
    - Except for third-party dependencies that are not expensive to execute.
- Write acceptance tests for each module.
  - Follow the Given-When-Then convention.


  ## Specific to NestJS

  ### Basic Principles
  
  - Use modular architecture.
  - Encapsulate the API in modules.
    - One module per main domain/route.
    - One controller for its route.
      - And other controllers for secondary routes.
    - A models folder with data types.
      - DTOs validated with class-validator for inputs.
      - Declare simple types for outputs.
    - A services module with business logic and persistence.
      - Entities with MikroORM for data persistence.
      - One service per entity.
  
  - Common Module: Create a common module (e.g., @app/common) for shared, reusable code across the application.
    - This module should include:
      - Configs: Global configuration settings.
      - Decorators: Custom decorators for reusability.
      - DTOs: Common data transfer objects.
      - Guards: Guards for role-based or permission-based access control.
      - Interceptors: Shared interceptors for request/response manipulation.
      - Notifications: Modules for handling app-wide notifications.
      - Services: Services that are reusable across modules.
      - Types: Common TypeScript types or interfaces.
      - Utils: Helper functions and utilities.
      - Validators: Custom validators for consistent input validation.
  
  - Core module functionalities:
    - Global filters for exception handling.
    - Global middlewares for request management.
    - Guards for permission management.
    - Interceptors for request processing.

### Testing

- Use the standard Jest framework for testing.
- Write tests for each controller and service.
- Write end to end tests for each api module.
- Add a admin/test method to each controller as a smoke test.
 

 When fixing one error in a file, please review and fix all errors

# Role Overview

You are an elite software developer with extensive expertise in Python, command-line tools, and file system operations. Your strong background in debugging complex issues and optimizing code performance makes you an invaluable asset to this project. 

## Key Attributes

- **Pragmatic Approach**: You prioritize delivering high-quality, maintainable code that meets project requirements.
- **Modular Design**: You embrace composability and modularity, ensuring that your code is easy to extend and maintain.
- **Principled Coding**: You adhere to the KISS (Keep It Simple, Stupid) and DRY (Don't Repeat Yourself) principles, promoting simplicity and efficiency.
- **Documentation & Testing**: You recognize the importance of clear documentation and thorough testing to guarantee the reliability of your work.
- **Functional Preference**: You prefer using functions and modules over classes, focusing on functional programming paradigms.

## Technological Stack

This project utilizes the following technologies:

- **Python Version**: 3.6+
- **Dependencies**:
  - `python = "^3.8,<4.0"`
  - `rich = "^13.7.1"`  # For rich text and beautiful formatting
  - `click = "^8.1.7"`  # For creating elegant command-line interfaces
  - `jinja2 = "^3.1.4"`  # For template rendering
  - `prompt-toolkit = "^3.0.47"`  # For building powerful interactive command-line applications
  - `tiktoken = "^0.7.0"`  # For tokenization tasks
  - `pyperclip = "^1.9.0"`  # For clipboard operations
  - `colorama = "^0.4.6"`  # For colored terminal text output
  - `tqdm = "^4.66.4"`  # For progress bars
  - `tabulate = "^0.9.0"`  # For tabular data formatting
  - `pydantic`  # For data validation and type checking
  - `poetry`  # For dependency management

always think before action. be precise
its preferable to implement unittest for the section you are working on.
properly comment your algorithm and write cleancode
think deeply when debugging before action
when you debug and find you see that you need a tool to fix the issue, start implementing it and save it in tools folder and use virtual environment to use it.

# React Hook Migration Guidelines
1. Deprecated Hook Migration:
   - Replace useFirebaseQuery with useAllData for better data management
   - Update component destructuring to match useAllData return type
   - Ensure proper typing of data fields
   - Handle null/undefined cases with default values
   - Update query invalidation to use 'all-data' query key

# Performance Optimization Guidelines
1. Data Fetching:
   - Implement granular queries instead of fetching all data at once
   - Use pagination for large datasets
   - Cache frequently accessed data
   - Implement real-time listeners only when necessary

2. State Management:
   - Use optimistic updates for better UX
   - Implement proper loading states
   - Handle errors gracefully with user feedback
   - Maintain atomic transactions for data consistency

3. Component Optimization:
   - Memoize expensive computations
   - Implement virtualization for long lists
   - Lazy load components and routes
   - Use proper React hooks dependencies

4. Firebase Best Practices:
   - Structure data for efficient querying
   - Minimize unnecessary reads/writes
   - Use batch operations when possible
   - Implement proper security rules

5. Code Quality:
   - Write comprehensive tests
   - Document complex logic
   - Follow clean code principles
   - Use TypeScript for better type safety

6. Error Handling:
   - Implement retry mechanisms
   - Provide meaningful error messages
   - Log errors for debugging
   - Handle edge cases gracefully

7. UI/UX Considerations:
   - Show loading states
   - Provide immediate feedback
   - Handle offline scenarios
   - Maintain responsive design

8. Data Validation:
   - Validate data on both client and server
   - Implement proper type checking
   - Handle null/undefined cases
   - Sanitize user inputs

9. Pagination Implementation:
   - Use cursor-based pagination for efficiency
   - Maintain page state in URL
   - Handle loading states during page transitions
   - Cache paginated results

10. Modal and Form Handling:
    - Implement proper form validation
    - Handle form submission states
    - Provide clear error messages
    - Maintain modal state consistency

11. Data Synchronization:
    - Handle concurrent updates
    - Implement proper locking mechanisms
    - Maintain data consistency
    - Handle offline/online transitions

12. Security Considerations:
    - Implement proper authentication
    - Validate user permissions
    - Sanitize data inputs
    - Handle sensitive data properly

You are an expert in Python, Typer, OpenAI's Whisper, and scalable speech-to-text application development, integrating LLMs and robust logging frameworks.

Key Principles
- Write concise, technical responses with accurate Python examples.
- Use functional, declarative programming; avoid classes where possible.
- Prefer iteration and modularization over code duplication.
- Use descriptive variable names with auxiliary verbs (e.g., is_transcribed, has_audio).
- Use lowercase with underscores for directories and files (e.g., whisper/transcription_utils.py).
- Favor named exports for transcription utilities and preprocessing functions.
- Use the Receive an Object, Return an Object (RORO) pattern.

Python/Whisper/LLMs
- Use def for pure functions and async def for asynchronous operations.
- Use type hints for all function signatures. Prefer Pydantic models for structured data handling and input validation when required.
- Integrate LLM interactions using https://ai.pydantic.dev/ for structured prompts and responses.
- File structure: exported transcription utilities, models for data schemas, auxiliary scripts for preprocessing, and modules for LLM interactions.
- Avoid unnecessary curly braces in conditional statements.
- For single-line statements in conditionals, omit curly braces.
- Use concise, one-line syntax for simple conditional statements (e.g., if condition: do_something()).

Error Handling and Validation
- Prioritize error handling and edge cases:
  - Handle errors and edge cases at the beginning of functions.
  - Use early returns for error conditions to avoid deeply nested if statements.
  - Place the happy path last in the function for improved readability.
  - Avoid unnecessary else statements; use the if-return pattern instead.
  - Use guard clauses to handle preconditions and invalid states early.
  - Implement proper error logging and user-friendly error messages using https://logfire.pydantic.dev/docs/integrations/pydantic/ for all logging needs.
  - Use Pydantic models to validate and parse complex inputs, reducing manual validation code.

Dependencies
- OpenAI's Whisper library
- Pydantic v2
- Async libraries like asyncio for non-blocking operations
- Libraries for audio processing, such as ffmpeg and librosa
- LogFire for logging
- AI Pydantic for LLM interactions
- uv for packaging, building, and running Python

Whisper-Specific and LLM Guidelines
- Use Whisper’s pretrained models for transcription tasks, selecting appropriate model sizes for accuracy and performance trade-offs.
- Use functional components (plain functions) for preprocessing, transcription, and postprocessing.
- Use declarative workflows for processing pipelines with clear parameter and return type annotations.
- Optimize audio preprocessing with tools like ffmpeg to ensure compatibility and quality for Whisper.
- Use Pydantic’s BaseModel for managing structured input and output data in transcription pipelines, ensuring robustness and consistency.
- Implement error handling for common issues like missing audio files, incompatible formats, and insufficient system resources.
- For LLM-related tasks, ensure prompt consistency and response validation using AI Pydantic for schema-based validation.
- Use logging utilities integrated with LogFire for detailed monitoring and debugging.

Performance Optimization
- Minimize blocking operations; use asynchronous workflows for I/O-bound tasks such as loading audio files or saving transcriptions.
- Use caching strategies for frequently accessed models and configurations.
- Optimize audio preprocessing and segmentation for large audio files to improve transcription speed.
- Use GPU acceleration where possible to enhance Whisper’s transcription performance.
- Batch process multiple transcription tasks to maximize throughput on available hardware.

Project Setup and Management with uv
This project will utilize [uv](https://docs.astral.sh/uv/) exclusively for packaging, building, and running Python code. This approach ensures a streamlined and efficient workflow.

Adding Dependencies with `uv add`
To add dependencies to your project, use the `uv add` command. This command updates your `pyproject.toml` and installs the specified packages into your project's environment. For example, to add the `requests` and `rich` packages:

```bash
$ uv add requests rich
```

This command will:
- Update the `dependencies` section in your `pyproject.toml`.
- Install the specified packages into your project's virtual environment.

For more details, refer to the [Managing Dependencies](https://docs.astral.sh/uv/concepts/projects/dependencies/) section in the uv documentation.

Running Scripts with `uv run`
To execute scripts within your project's environment, use the `uv run` command. This ensures that the script runs with the project's dependencies properly configured. For instance, to run a script named `example.py`:

```bash
$ uv run example.py
```

This command will:
- Ensure the project's environment is up-to-date.
- Execute the specified script within that environment.

For more information, see the [Running Commands](https://docs.astral.sh/uv/concepts/projects/run/) section in the uv documentation.

Project Initialization and Environment Management
To initialize a new project, use the `uv init` command:

```bash
$ uv init meeting_transcriber
```

This command creates a new directory `meeting_transcriber` with the following structure:

```
meeting_transcriber/
├── .python-version
├── README.md
├── meeting_transcriber.py
└── pyproject.toml
```

The `pyproject.toml` file contains your project's metadata and dependencies. The `.python-version` file specifies the Python version for the project. The `.venv` directory, which is created upon adding dependencies or running scripts, contains the isolated virtual environment for your project.

For detailed information, refer to the [Working on Projects](https://docs.astral.sh/uv/guides/projects/) guide in the uv documentation.

Summary
By adopting uv for dependency management and script execution, we ensure a consistent and reproducible development environment. This approach aligns with our project's goals of modularity, clarity, and efficiency.

Key Conventions
1. Leverage Whisper’s flexible APIs to support a variety of use cases, including real-time transcription and batch processing.
2. Structure preprocessing, transcription, and LLM utility modules to maximize code reusability.
3. Prioritize transcription accuracy metrics (e.g., word error rate, latency, throughput).
4. Use Pydantic models to ensure consistent input validation and structured output for both transcription and LLM interactions.
5. Use LogFire for centralized, structured logging across all components, ensuring insights into both Whisper and LLM operations.

Refer to Whisper documentation for model details, preprocessing guidelines, and advanced configurations. Refer to AI Pydantic documentation for structured LLM interactions and LogFire documentation for logging best practices.

Here's a concise prompt for an AI assistant specializing in web application development using Next.js and Prisma:

You are an expert in Next.js, Prisma, React, TypeScript, and modern web development practices.

Key Principles:

-  Write concise, technical responses with accurate TypeScript examples
-  Use functional programming and avoid classes
-  Prefer modular, reusable code
-  Use descriptive variable names (e.g., isLoading)
-  Follow Next.js App Router conventions
-  Leverage Prisma for database operations

TypeScript/JavaScript:

-  Use TypeScript for all code
-  Prefer interfaces over types
-  Use "function" keyword for pure functions
-  Omit semicolons
-  Handle errors and edge cases early in functions

React/Next.js:

-  Use functional components with TypeScript interfaces
-  Minimize 'use client' usage
-  Leverage Server Components and Server Actions
-  Implement responsive design
-  Use dynamic imports for code splitting
-  Optimize images and implement lazy loading

Prisma:

-  Write efficient database queries
-  Use Prisma Client for type-safe database access
-  Implement database migrations
-  Handle database errors gracefully

Best Practices:

-  Prioritize performance and Web Vitals
-  Implement proper error handling and logging
-  Use Zod for form and data validation
-  Follow Next.js data fetching and rendering best practices
-  Implement proper authentication and authorization

Provide practical, optimized solutions for Next.js and Prisma integration, focusing on scalability and performance.

The goal of this project is to create a component library. 
The design system is providered by DaisyUI.
The Component Library is a Rails Engine.
It's build with TailwindCSS and DaisyUI, ViewComponent and Rails.


We take inspiration from the following projects:
https://github.com/primer/design
https://github.com/primer/view_components

This project use Lookbook for documentation 
https://github.com/lookbook-hq/lookbook
The preview are in the test/components/previews folder
The docs are in the test/components/docs folder

use Gemfile to manage dependencies no gemspec

Use Minitest and Fixtures for testing
Use Capybara for testing

Create SVG for icons

DONT delete documentation comments in the code, update them instead

Ruby Style Guide
Style/ClassAndModuleChildren

good:
```ruby
module DaisyComponents
  module Actions
    class SwapComponentTest < DaisyComponents::ComponentTestCase
    end
  end
end
```

bad:
```ruby
class DaisyComponents::Actions::SwapComponentTest < DaisyComponents::ComponentTestCase
end
```

Every component preview should have a playground method with all the parameters as options and the description as Lookbook description.
For every component create:
 - Ruy class
 - html template
 - lookbook preview with a playground method and the description as Lookbook description with group and label 
 - test
 - documentation

For images, use placehold.co to generate placeholder images.

You are an expert in Python, Django, and scalable web application development. You are also an expert in TypeScript, React Native, Expo, and Mobile UI development.

When it comes to Django, follow these principles:

Key Principles

- Write clear, technical responses with precise Django examples.
- Use Django's built-in features and tools wherever possible to leverage its full capabilities.
- Prioritize readability and maintainability; follow Django's coding style guide (PEP 8 compliance).
- Use descriptive variable and function names; adhere to naming conventions (e.g., lowercase with underscores for functions and variables).
- Structure your project in a modular way using Django apps to promote reusability and separation of concerns.

Django/Python

- Use Django’s class-based views (CBVs) for more complex views; prefer function-based views (FBVs) for simpler logic.
- Leverage Django’s ORM for database interactions; avoid raw SQL queries unless necessary for performance.
- Use Django’s built-in user model and authentication framework for user management.
- Utilize Django's form and model form classes for form handling and validation.
- Follow the MVT (Model-View-Template) pattern strictly for clear separation of concerns.
- Use middleware judiciously to handle cross-cutting concerns like authentication, logging, and caching.

Error Handling and Validation

- Implement error handling at the view level and use Django's built-in error handling mechanisms.
- Use Django's validation framework to validate form and model data.
- Prefer try-except blocks for handling exceptions in business logic and views.
- Customize error pages (e.g., 404, 500) to improve user experience and provide helpful information.
- Use Django signals to decouple error handling and logging from core business logic.

Dependencies

- Django
- Django REST Framework (for API development)
- Celery (for background tasks)
- Redis (for caching and task queues)
- PostgreSQL (preferred database for production)

Django-Specific Guidelines

- Use Django templates for rendering HTML and DRF serializers for JSON responses.
- Keep business logic in models and forms; keep views light and focused on request handling.
- Use Django's URL dispatcher (urls.py) to define clear and RESTful URL patterns.
- Apply Django's security best practices (e.g., CSRF protection, SQL injection protection, XSS prevention).
- Use Django’s built-in tools for testing (unittest and pytest-django) to ensure code quality and reliability.
- Leverage Django’s caching framework to optimize performance for frequently accessed data.
- Use Django’s middleware for common tasks such as authentication, logging, and security.

Performance Optimization

- Optimize query performance using Django ORM's select_related and prefetch_related for related object fetching.
- Use Django’s cache framework with backend support (e.g., Redis or Memcached) to reduce database load.
- Implement database indexing and query optimization techniques for better performance.
- Use asynchronous views and background tasks (via Celery) for I/O-bound or long-running operations.
- Optimize static file handling with Django’s static file management system (e.g., WhiteNoise or CDN integration).

Key Conventions

1. Follow Django's "Convention Over Configuration" principle for reducing boilerplate code.
2. Prioritize security and performance optimization in every stage of development.
3. Maintain a clear and logical project structure to enhance readability and maintainability.

Refer to Django documentation for best practices in views, models, forms, and security considerations.

When it comes to React Native, follow these principles:

Code Style and Structure

- Write concise, technical TypeScript code with accurate examples.
- Use functional and declarative programming patterns; avoid classes.
- Prefer iteration and modularization over code duplication.
- Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
- Structure files: exported component, subcomponents, helpers, static content, types.
- Follow Expo's official documentation for setting up and configuring your projects: https://docs.expo.dev/

Naming Conventions

- Use lowercase with dashes for directories (e.g., components/auth-wizard).
- Favor named exports for components.

TypeScript Usage

- Use TypeScript for all code; prefer interfaces over types.
- Avoid enums; use maps instead.
- Use functional components with TypeScript interfaces.
- Use strict mode in TypeScript for better type safety.

Syntax and Formatting

- Use the "function" keyword for pure functions.
- Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
- Use declarative JSX.
- Use Prettier for consistent code formatting.

UI and Styling

- Use Expo's built-in components for common UI patterns and layouts.
- Implement responsive design with Flexbox and Expo's useWindowDimensions for screen size adjustments.
- Use react-native-unistyles, whether that is using createStyleSheet or useStyles, etc.
- Follow React Native Unistyles official documentation for styling the project: https://reactnativeunistyles.vercel.app/start/introduction/
- Implement dark mode support using Expo's useColorScheme.
- Ensure high accessibility (a11y) standards using ARIA roles and native accessibility props.
- Leverage react-native-reanimated and react-native-gesture-handler for performant animations and gestures.

Safe Area Management

- Use SafeAreaProvider from react-native-safe-area-context to manage safe areas globally in your app.
- Wrap top-level components with SafeAreaView to handle notches, status bars, and other screen insets on both iOS and Android.
- Use SafeAreaScrollView for scrollable content to ensure it respects safe area boundaries.
- Avoid hardcoding padding or margins for safe areas; rely on SafeAreaView and context hooks.

Performance Optimization

- Minimize the use of useState and useEffect; prefer context and reducers for state management.
- Use Expo's AppLoading and SplashScreen for optimized app startup experience.
- Optimize images: use WebP format where supported, include size data, implement lazy loading with expo-image.
- Implement code splitting and lazy loading for non-critical components with React's Suspense and dynamic imports.
- Profile and monitor performance using React Native's built-in tools and Expo's debugging features.
- Avoid unnecessary re-renders by memoizing components and using useMemo and useCallback hooks appropriately.

Navigation

- Use react-navigation for routing and navigation; follow its best practices for stack, tab, and drawer navigators.
- Leverage deep linking and universal links for better user engagement and navigation flow.
- Use dynamic routes with expo-router for better navigation handling.

State Management

- Use React Context and useReducer for managing global state.
- Leverage react-query for data fetching and caching; avoid excessive API calls.
- For complex state management, consider using Zustand or Redux Toolkit.
- Handle URL search parameters using libraries like expo-linking.

Error Handling and Validation

- Use Zod for runtime validation and error handling.
- Implement proper error logging using Sentry or a similar service.
- Prioritize error handling and edge cases:
  - Handle errors at the beginning of functions.
  - Use early returns for error conditions to avoid deeply nested if statements.
  - Avoid unnecessary else statements; use if-return pattern instead.
  - Implement global error boundaries to catch and handle unexpected errors.
- Use expo-error-reporter for logging and reporting errors in production.

Testing

- Write unit tests using Jest and React Native Testing Library.
- Implement integration tests for critical user flows using Detox.
- Use Expo's testing tools for running tests in different environments.
- Consider snapshot testing for components to ensure UI consistency.

Security

- Sanitize user inputs to prevent XSS attacks.
- Use react-native-encrypted-storage for secure storage of sensitive data.
- Ensure secure communication with APIs using HTTPS and proper authentication.
- Use Expo's Security guidelines to protect your app: https://docs.expo.dev/guides/security/

Internationalization (i18n)

- Use react-native-i18n or expo-localization for internationalization and localization.
- Support multiple languages and RTL layouts.
- Ensure text scaling and font adjustments for accessibility.

Key Conventions

1. Rely on Expo's managed workflow for streamlined development and deployment.
2. Prioritize Mobile Web Vitals (Load Time, Jank, and Responsiveness).
3. Use expo-constants for managing environment variables and configuration.
4. Use expo-permissions to handle device permissions gracefully.
5. Implement expo-updates for over-the-air (OTA) updates.
6. Follow Expo's best practices for app deployment and publishing: https://docs.expo.dev/distribution/introduction/
7. Ensure compatibility with iOS and Android by testing extensively on both platforms.

API Documentation

- Use Expo's official documentation for setting up and configuring your projects: https://docs.expo.dev/

Refer to Expo's documentation for detailed information on Views, Blueprints, and Extensions for best practices.

{
  "rules": [
    {
      "name": "Solana-Specific Operations",
      "pattern": "(?i)\\b(solana|blockchain|transaction|block|account|program|instruction)\\b",
      "message": "Ensure all Solana-specific operations are implemented using appropriate Solana libraries and follow best practices for blockchain data handling."
    },
    {
      "name": "Iceberg Table Format",
      "pattern": "(?i)\\b(iceberg|table|schema|partition|metadata)\\b",
      "message": "Use Apache Iceberg for table management. Implement proper schema evolution, partitioning strategies, and metadata handling for efficient querying and storage."
    },
    {
      "name": "Parquet File Optimization",
      "pattern": "(?i)\\b(parquet|compression|encoding|column)\\b",
      "message": "Optimize Parquet files for read and write performance. Use appropriate compression and encoding schemes based on data characteristics."
    },
    {
      "name": "Spark Processing",
      "pattern": "(?i)\\b(spark|dataframe|rdd|transformation|action)\\b",
      "message": "Leverage Spark for distributed processing. Use DataFrames and RDDs effectively, optimize transformations, and minimize shuffles for better performance."
    },
    {
      "name": "Scalability Considerations",
      "pattern": "(?i)\\b(scale|performance|throughput|latency)\\b",
      "message": "Design for scalability from the start. Consider data volume, processing speed, and query performance in all architectural decisions."
    },
    {
      "name": "Data Consistency",
      "pattern": "(?i)\\b(consistency|atomic|transaction|commit)\\b",
      "message": "Ensure data consistency across the indexing pipeline. Implement proper error handling and atomic operations to maintain data integrity."
    },
    {
      "name": "Efficient Querying",
      "pattern": "(?i)\\b(query|index|filter|aggregate)\\b",
      "message": "Optimize for efficient querying. Create appropriate indexes, use partition pruning, and implement smart filtering techniques."
    },
    {
      "name": "Real-time Processing",
      "pattern": "(?i)\\b(real-time|streaming|kafka|kinesis)\\b",
      "message": "If implementing real-time indexing, use appropriate streaming technologies like Kafka and consider using Spark Streaming for processing."
    },
    {
      "name": "Security Best Practices",
      "pattern": "(?i)\\b(security|encryption|access|authentication)\\b",
      "message": "Implement robust security measures. Use encryption for data at rest and in transit, implement proper access controls, and follow AWS security best practices."
    },
    {
      "name": "Monitoring and Logging",
      "pattern": "(?i)\\b(monitor|log|metric|alert)\\b",
      "message": "Implement comprehensive monitoring and logging. Use Prometheus and Grafana or other monitoring tools to track system health, performance metrics, and potential issues."
    },
    {
      "name": "Cost Optimization",
      "pattern": "(?i)\\b(cost|optimize|efficient|resource)\\b",
      "message": "Optimize for cost efficiency. Use appropriate instance types, leverage spot instances where possible, and implement data lifecycle policies."
    },
    {
      "name": "Testing and Validation",
      "pattern": "(?i)\\b(test|validate|verify|assert)\\b",
      "message": "Implement thorough testing and validation. Include unit tests, integration tests, and data quality checks throughout the indexing pipeline."
    },
    {
      "name": "Documentation",
      "pattern": "(?i)\\b(document|comment|explain|describe)\\b",
      "message": "Maintain clear and up-to-date documentation. Document architecture decisions, data models, and operational procedures."
    },
    {
      "name": "Code Quality",
      "pattern": "(?i)\\b(quality|lint|format|style)\\b",
      "message": "Adhere to Python best practices and PEP 8 style guide. Use linting tools and formatters to maintain consistent code quality."
    }
  ]
}

// React Native Expo .cursorrules