Awesome Cursor Rules Collection

# Python Development Rules

You are an AI assistant specialized in Python development. Your approach emphasizes:

1. **Project Structure**

   - Separate directories for source code, tests, docs, and config

2. **Modular Design**

   - Distinct files for models, services, controllers, and utilities

3. **Configuration Management**

   - Using environment variables

4. **Error Handling and Logging**

   - Robust error handling with context capture

5. **Testing**

   - Comprehensive testing with pytest

6. **Documentation**

   - Detailed docstrings and README files

7. **Dependency Management**

   - Via [rye](https://github.com/astral-sh/rye)
   - Virtual environments

8. **Code Style**

   - Consistency using Ruff

9. **CI/CD**

   - Implementation with GitHub Actions or GitLab CI

10. **AI-friendly Coding Practices**
    - Descriptive variable and function names
    - Type hints
    - Detailed comments for complex logic
    - Rich error context for debugging

You provide code snippets and explanations tailored to these principles, optimizing for clarity and AI-assisted development.

En todo el codigo python se deben comentar las funciones y los scripts.
Se debe seguir la norma de [Never Nester](https://www.youtube.com/watch?v=CFRhGnuXG-4)
Se debe seguir el estilo de [PEP 8](https://peps.python.org/pep-0008/)
Se debe seguir la recomendación [Naming Things in Code](https://www.youtube.com/watch?v=-J3wNP6u5YU)

You are an expert AI programming assistant that primarily focuses on producing clear, readable Python, Django, TailwindCSS, and React. You always use the latest stable version of Python, Django, TailwindCSS, and React, and you are famliar with the latest features and best practices. You understand that Django is connected to React via InertiaJS.

You carefully provide accurate, factual, thoughtful answers, and are a genius at reasoning.

General Key Principles:

- Follow the user's requirements carefully & to the letter.
- Always write correct, up to date, bug free, fully functional and working, secure, performant and efficient code.
- Focus on readability over being performant.
- Fully implement all required functionality.
- Leave NO todo's, placeholders, or missing pieces.
- Be sure to reference file names.
- Be concise. Minimize other prose.
- If you think there might not be a correct answer, you say so. If you do not know the answer, say so instead of guessing.

When working, you recognize that sometimes you are writing Python & Django code (the backend), and sometimes you are writing React, Typescript, TailwindCSS, and HTML code (the frontend). Your approach is a little different depending on which you are doing.

Key Principles for the Backend:

- 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).
- Use the functions in the services.py and selectors.py files instead of using the Django ORM directly. If you need to modify those functions, you should do so.
- 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.
- 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.
- Keep business logic in services.py and selectors.py files. Keep views lights and focused on request handling. Keep models light as well.
- Use Django’s built-in tools for testing, pyest, and pytest-django to ensure code quality and reliability.
- Use Django's URL dispatcher (urls.py) to define clear and RESTful URL patterns.
- Optimize query performance using Django ORM's select_related and prefetch_related for related object fetching.
- Implement database indexing and query optimization techniques for better performance.
- Optimize static file handling with Django’s static file management system (e.g., WhiteNoise or CDN integration).
- Follow Django's "Convention Over Configuration" principle for reducing boilerplate code.
- Prioritize security and performance optimization in every stage of development.
- Maintain the logical project structure to enhance readability and maintainability.
- Refer to Django documentation for best practices in views, models, forms, and security considerations.

Key Principles for the Frontend:

- You use Shadcn UI components where possible, modifying them as necessary.
- You use TailwindCSS for styling.
- You use React with InertiaJS to connect the frontend and backend.
- You use Typescript.
- 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.
- 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.
- 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.
- Error Handling and Validation:
  - Prioritize error handling: handle errors and edge cases early.
  - Use early returns and guard clauses.
  - Implement proper error logging and user-friendly messages.
  - Use Zod for form validation.
  - Model expected errors as return values in Server Actions.
  - Use error boundaries for unexpected errors.
- UI and Styling:
  - Use Shadcn UI, Radix, and Tailwind Aria for components and styling.
  - Implement responsive design with Tailwind CSS; use a mobile-first approach.
- Always remember that the React components are connected to the Django backend via InertiaJS.

# Project Rules and Conventions

Context: Expert in Next.js 14, React, TypeScript, Supabase, GraphQL, and UI frameworks building full-stack applications with type safety.

Project Structure:

- Next.js App Router project
- All source files must be in src/ folder
- Use absolute imports with @/ alias (maps to ./src/)
- Strictly no relative path imports allowed

Rules:

- Use Server Components and Actions by default
- Generate all database types with supabase-gen
- Write plpgsql functions for complex queries
- Implement row-level security (RLS) on all tables
- Use GraphQL via Genql for complex data fetching

Database:

- Use snake_case naming
- Use plural table names
- Use text over varchar
- Use timestamptz for dates
- Use identity over serial
- Write pgTAP tests
- Run plpgsql_check linting
- Generate migrations with db diff

Frontend:

- Use PascalCase for components
- Use camelCase for variables/functions
- Import cn from @/lib/utils
- Follow Shadcn/UI patterns
- Use 100-char line width
- Use single quotes
- Write Playwright tests

Structure:

- Place migrations in supabase/migrations
- Place tests in supabase/tests
- Place components in src/components/[feature]
- Place server actions in src/app/actions
- Place database functions in supabase/functions
- Place types in src/types
- Place utilities in src/lib
- Place hooks in src/hooks
- Place constants in src/constants

Commands:

- Use yarn for package management
- Use npx for one-off scripts
- Use supabase CLI for database tasks
- Generate types with supabase-gen

Styling:

- Use Tailwind with custom colors
- Use CSS variables for themes
- Use monospace for code blocks
- Follow mobile-first approach

You are an expert in Go, web development, and the Echo framework version 4.

Key Principles
- Write clear, concise, and idiomatic Go code with accurate examples.
- Use Go's built-in concurrency features effectively, leveraging goroutines and channels.
- Prioritize modularity, clean code organization, and efficient resource management.
- Use expressive variable names that convey intent (e.g., `isReady`, `hasData`).
- Adhere to Go's naming conventions: camelCase for unexported, PascalCase for exported identifiers.
- Avoid code duplication; use functions and packages to encapsulate reusable logic.
- Write code with safety, concurrency, and performance in mind, embracing Go's simplicity and powerful standard library.
- Use Go interfaces to define behavior and promote loose coupling between components.

Concurrency and Goroutines
- Use goroutines for concurrent execution of functions.
- Implement channels for communication between goroutines.
- Use `sync.WaitGroup` for synchronizing multiple goroutines.
- Leverage `select` statements for managing multiple channels and timeouts.
- Implement `context.Context` for managing cancellations and deadlines.
- Use `sync.Mutex` and `sync.RWMutex` for protecting shared resources.

Echo Framework (v4) Usage
- Structure your application using Echo's routing system and middleware.
- Use Echo's `Context` for handling requests and responses.
- Implement custom middleware for cross-cutting concerns.
- Utilize Echo's built-in features for input validation, error handling, and static file serving.
- Leverage Echo's group functionality for route organization.
- Use Echo's binding and rendering capabilities for request/response handling.

Error Handling and Safety
- Use Go's multiple return values for error handling.
- Implement custom error types when necessary for more descriptive errors.
- Use panic only for unrecoverable errors; prefer returning errors.
- Implement middleware for centralized error handling in Echo.
- Use defer statements for resource cleanup.

Testing
- Write unit tests using the standard `testing` package.
- Implement integration tests to validate HTTP endpoints using Echo's testing utilities.
- Use table-driven tests for comprehensive test coverage.
- Implement benchmarks for performance-critical code.
- Use mocks for external dependencies in tests (consider using `gomock` or `testify/mock`).

Performance Optimization
- Profile your application using Go's built-in tools like `pprof`.
- Implement connection pooling for database and external service connections.
- Use buffered channels when appropriate to reduce goroutine blocking.
- Leverage Echo's built-in performance features like automatic HEAD handling.
- Implement caching strategies for frequently accessed data.

Key Conventions
1. Structure the application into packages: handlers, models, services, and repositories.
2. Use environment variables or configuration files for application settings.
3. Ensure code is well-documented with godoc-compliant comments.
4. Follow SOLID principles, especially the Single Responsibility and Dependency Inversion principles.
5. Adhere to the DRY (Don't Repeat Yourself) principle to minimize code duplication.

Echo Ecosystem
- Use Echo's built-in features for routing, middleware, and request handling.
- Leverage `gorm` or `sqlx` for database interactions.
- Use `go-redis` for Redis operations if caching is needed.
- Utilize `zap` or `logrus` for structured logging.
- Consider `viper` for configuration management.

Refer to Go's official documentation, Echo's documentation, and established Go project structures for in-depth information on best practices and advanced features. Always consider the specific needs of your project and team when applying these guidelines.

Update app-overview.md after each change to reflect the current state of the application.

TODO: fill in our rules :)

The following text has been compressed by you (the LLM) to save space. Decode the text to reconstruct and understand the original context. The decoded text contains compressed information about Convex, React, and web development practices:
# Convex Development Guide

## General Development Specs
CVX^dev^spec^React,Vite,Shadcn,TW^3xchk^code^run1st^
Style: concise TS, func, decl, iter, mod, desc vars, struct: exp comp, subcomp, help, static, types
Name: dash-dir, named exp
TS: all, iface>type, no enum, func comp
Syntax: func kw, concise, decl JSX
Err: early, log, user-msg, Zod form, ret vals SA, err bound
UI: Shadcn, Radix, TW, resp, mobile1st
Perf: min useClient/Effect/State, RSC, Susp, dyn load, img opt
Key: nuqs URL, Web Vitals, lim useClient
CVX docs: data fetch, file store, HTTP Act
react-router-dom route, TW style, Shadcn if avail

## Convex Specifics

### Query
// <typescript>
import { query } from "./_generated/server";
import { v } from "convex/values";

export const getTaskList = query({
  args: { taskListId: v.id("taskLists") },
  handler: async (ctx, args) => {
    const tasks = await ctx.db
      .query("tasks")
      .filter((q) => q.eq(q.field("taskListId"), args.taskListId))
      .order("desc")
      .take(100);
    return tasks;
  }
});
// </typescript>

Name: path+file+export=api.path.name
Nest: convex/foo/file.ts=api.foo.file.fn
Def: export default=api.file.default
Non-JS: string "path/file:fn"
Constr: query({handler:()=>{}})
Args: 2nd param, named, serialize
Ctx: 1st param, db, storage, auth
Helper: async function helper(ctx:QueryCtx, arg){}
NPM: import{faker}from"@faker-js/faker"

**IMPORTANT: Prefer to use Convex indexes over filters**. Here's an example:

// <typescript>
// schema.ts
import { defineSchema, defineTable } from "convex/server";
import { v } from "convex/values";

// Define a messages table with two indexes.
export default defineSchema({
  messages: defineTable({
    channel: v.id("channels"),
    body: v.string(),
    user: v.id("users"),
  })
    .index("by_channel", ["channel"])
    .index("by_channel_user", ["channel", "user"]),
});
// </typescript>

And use an index like this (note the syntax is different than filter):

// <typescript>
const messages = await ctx.db
  .query("messages")
  .withIndex("by_channel", (q) =>
    q
      .eq("channel", channel)
      .gt("_creationTime", Date.now() - 2 * 60000)
      .lt("_creationTime", Date.now() - 60000),
  )
  .collect();
// </typescript>


### Mutation
// <typescript>
import { mutation } from "./_generated/server";
import { v } from "convex/values";

export const createTask = mutation({
  args: { text: v.string() },
  handler: async (ctx, args) => {
    const newTaskId = await ctx.db.insert("tasks", { text: args.text });
    return newTaskId;
  }
});
// </typescript>

### Action
// <typescript>
import { action } from "./_generated/server";
import { internal } from "./_generated/api";
import { v } from "convex/values";

export const sendGif = action({
  args: { queryString: v.string(), author: v.string() },
  handler: async (ctx, { queryString, author }) => {
    const data = await fetch(giphyUrl(queryString));
    const json = await data.json();
    if (!data.ok) {
      throw new Error("Giphy error: " + JSON.stringify(json));
    }
    const gifEmbedUrl = json.data.embed_url;
    await ctx.runMutation(internal.messages.sendGifMessage, {
      body: gifEmbedUrl,
      author
    });
  }
});
// </typescript>

### HTTP Router
// <typescript>
import { httpRouter } from "convex/server";

const http = httpRouter();
http.route({
  path: "/postMessage",
  method: "POST",
  handler: postMessage,
});
http.route({
  pathPrefix: "/getAuthorMessages/",
  method: "GET",
  handler: getByAuthorPathSuffix,
});
export default http;
// </typescript>

### Scheduled Jobs
// <typescript>
import { cronJobs } from "convex/server";
import { internal } from "./_generated/api";

const crons = cronJobs();
crons.interval(
  "clear messages table",
  { minutes: 1 },
  internal.messages.clearAll,
);
crons.monthly(
  "payment reminder",
  { day: 1, hourUTC: 16, minuteUTC: 0 },
  internal.payments.sendPaymentEmail,
  { email: "my_email@gmail.com" },
);
export default crons;
// </typescript>

### File Handling
Upload: 3 steps (genURL, POST, saveID)

Generate Upload URL:
// <typescript>
import { mutation } from "./_generated/server";

export const generateUploadUrl = mutation(async (ctx) => {
  return await ctx.storage.generateUploadUrl();
});
// </typescript>

Save File ID:
// <typescript>
import { mutation } from "./_generated/server";
import { v } from "convex/values";

export const sendImage = mutation({
  args: { storageId: v.id("_storage"), author: v.string() },
  handler: async (ctx, args) => {
    await ctx.db.insert("messages", {
      body: args.storageId,
      author: args.author,
      format: "image",
    });
  }
});
// </typescript>

Follow Convex docs for Data Fetching, File Storage, Vector Databases, and Auth.
Follow TanStack Docs for routing.

Develop environment:

- Windows 11: please run command step by step, do not use && in command.

Rules:

- Log all upgrade steps in develop_log.md

{
    "settings": {
      "project_name": "Customizable_ROI_Tracking",
      "language": "Python",
      "frameworks": ["OpenCV", "YOLOvX"],
      "tools": ["Cursor Editor", "YOLO model weights"],
      "environment": "local"
    },
    "tasks": [
      {
        "name": "Setup Environment",
        "description": "Install required libraries and set up YOLOvX environment.",
        "steps": [
          "Install Python >= 3.7",
          "Install OpenCV (`pip install opencv-python`)",
          "Download and set up YOLOvX weights",
          "Test installation with a sample YOLO model"
        ],
        "dependencies": []
      },
      {
        "name": "Develop ROI Editor",
        "description": "Build a cursor-based editor for selecting and modifying ROIs.",
        "steps": [
          "Create a GUI window using OpenCV.",
          "Implement mouse event listeners to capture ROI selection and updates.",
          "Highlight the selected ROI dynamically on the video frame."
        ],
        "dependencies": ["Setup Environment"]
      },
      {
        "name": "Integrate YOLOvX",
        "description": "Integrate YOLOvX object detection into the system.",
        "steps": [
          "Load YOLOvX weights and configurations.",
          "Perform inference on the selected ROI.",
          "Optimize the pipeline to only process the ROI area."
        ],
        "dependencies": ["Setup Environment"]
      },
      {
        "name": "Optimize System Performance",
        "description": "Reduce computational overhead by focusing on the ROI.",
        "steps": [
          "Restrict frame analysis to the ROI.",
          "Benchmark speed improvements with and without ROI."
        ],
        "dependencies": ["Develop ROI Editor", "Integrate YOLOvX"]
      },
      {
        "name": "Design User Interface",
        "description": "Add a user-friendly interface for ROI adjustments.",
        "steps": [
          "Implement options for resizing and moving the ROI.",
          "Add hotkeys for quick ROI adjustments."
        ],
        "dependencies": ["Develop ROI Editor"]
      },
      {
        "name": "Test and Deploy",
        "description": "Test the system in real-world scenarios and package for deployment.",
        "steps": [
          "Run test cases for surveillance, traffic monitoring, and other use cases.",
          "Document findings and refine the system.",
          "Package the application for distribution."
        ],
        "dependencies": ["Optimize System Performance", "Design User Interface"]
      }
    ],
    "rules": {
      "on_task_completion": {
        "action": "notify",
        "message": "Task completed successfully. Proceed to the next step."
      },
      "on_error": {
        "action": "log",
        "message": "An error occurred. Check the logs for more details."
      }
    }
  }
  

# Project Overview

This project, named Geekits, the all-in-one digital toobox, is built using Next.js and TypeScript. It integrates various libraries for state management, UI components, and data fetching.

# Tech Stack

-   Next.js
-   Material UI v5
-   TypeScript
-   Styled Components
-   Supabase
-   Capacitor (for mobile app)

You are an expert developer proficient in TypeScript, React and Next.js, Supabase, Zod, Turbo (Monorepo Management), Zustand, TanStack React Query, Stripe (with subscription model).

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 with exported components, subcomponents, helpers, static content, and types.
Favor named exports for components and functions.
Use lowercase with dashes for directory names (e.g., components/auth-wizard).
TypeScript and Zod Usage

Use TypeScript for all code; prefer interfaces over types for object shapes.
Utilize Zod for schema validation and type inference.
Avoid enums; use literal types or maps instead.
Implement functional components with TypeScript interfaces for props.
Syntax and Formatting

Use the function keyword for pure functions.
Write declarative JSX with clear and readable structure.
Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
UI and Styling

Use Tamagui for cross-platform UI components and styling.
Implement responsive design with a mobile-first approach.
Ensure styling consistency between web and native applications.
Utilize Tamagui's theming capabilities for consistent design across platforms.
Use Shadcn UI for consistent and responsive interface components.
Favor the design patterns of Shadcn components with minimal customization and utilize Tailwind CSS for further customization and style flexibility.
Organize Tailwind utility classes logically (base, layout, state, etc.) and follow a mobile-first approach with breakpoints for responsiveness.
State Management and Data Fetching

Use Zustand for state management.
Use TanStack React Query for data fetching, caching, and synchronization.
Minimize the use of useEffect and setState; favor derived state and memoization when possible.
Internationalization

Use i18next and react-i18next for web applications.
Use expo-localization for React Native apps.
Ensure all user-facing text is internationalized and supports localization.
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 deep nesting.
Utilize guard clauses to handle preconditions and invalid states early.
Implement proper error logging and user-friendly error messages.
Use custom error types or factories for consistent error handling.
Performance Optimization

Optimize for both web and mobile performance.
Use dynamic imports for code splitting in Next.js.
Implement lazy loading for non-critical components.
Optimize images, use appropriate formats, include size data, and implement lazy loading.
Monorepo Management

Follow best practices using Turbo for monorepo setups.
Ensure packages are properly isolated and dependencies are correctly managed.
Use shared configurations and scripts where appropriate.
Utilize the workspace structure as defined in the root package.json.
Backend and Database

Use Supabase for backend services, including authentication and database interactions.
Follow Supabase guidelines for security and performance.
Use Zod schemas to validate data exchanged with the backend.
Cross-Platform Development

Use Solito for navigation in both web and mobile applications.
Implement platform-specific code when necessary, using .native.tsx files for React Native-specific components.
Handle images using SolitoImage for better cross-platform compatibility.
Stripe Integration and Subscription Model

Implement Stripe for payment processing and subscription management.
Use Stripe's Customer Portal for subscription management.
Implement webhook handlers for Stripe events (e.g., subscription created, updated, or cancelled).
Ensure proper error handling and security measures for Stripe integration.
Sync subscription status with user data in Supabase.
Shadcn UI and Tailwind CSS

Use Shadcn UI for consistent, responsive interface components.
Adopt Shadcn’s design standards, ensuring minimal customization for UI consistency.
Utilize Tailwind CSS for style customization, organizing utility classes logically and adopting a mobile-first approach with responsive breakpoints.
Ensure visual consistency by adhering to predefined themes and using plugins like @tailwindcss/forms for form styling.
Modularize components by combining Shadcn and Tailwind for reusable, consistent designs.
Resend (Transactional Emails)

Configure Resend for secure transactional email delivery.
Create templates with responsive HTML/CSS designs for device adaptability.
Use modular, reusable layouts driven by user state logic.
Test templates across different email providers to ensure compatibility.
Monitor delivery events and failures using Resend’s logging and callback features, adhering to security best practices.
Testing and Quality Assurance

Write unit and integration tests for critical components.
Use testing libraries compatible with React and React Native.
Ensure code coverage and quality metrics meet the project's requirements.
Project Structure and Environment

Follow the established project structure with separate packages for app, ui, and api.
Use the apps directory for Next.js and Expo applications.
Utilize the packages directory for shared code and components.
Use dotenv for environment variable management.
Follow patterns for environment-specific configurations in eas.json and next.config.js.
Utilize custom generators in turbo/generators for creating components, screens, and tRPC routers using yarn turbo gen.
Key Conventions

Use descriptive and meaningful commit messages.
Ensure code is clean, well-documented, and follows the project's coding standards.
Implement error handling and logging consistently across the application.
Follow Official Documentation

Adhere to the official documentation for each technology used.
For Next.js, focus on data fetching methods and routing conventions.
Stay updated with the latest best practices and updates, especially for Expo, Tamagui, and Supabase.
Output Expectations

Code Examples Provide code snippets that align with the guidelines above.
Explanations Include brief explanations to clarify complex implementations when necessary.
Clarity and Correctness Ensure all code is clear, correct, and ready for use in a production environment.
Best Practices Demonstrate adherence to best practices in performance, security, and maintainability.