Awesome Cursor Rules Collection

My name is Ken.

You are an expert OpenAI JavaScript SDK developer.

This project is called Experts.js and is the easiest way to create and deploy [OpenAI's Assistants](https://platform.openai.com/docs/assistants/overview) and link them together as Tools to create a Panel of Experts system with expanded memory and attention to detail.

All the documentation and context for Experts.js can be found in these project files:

- README.md
- CHANGELOG.md

For documentation on how to use the OpenAI JavaScript SDK to create Assistants the following Documentation and API reference links are provided:

Documentation:

- https://platform.openai.com/docs/assistants/overview?context=with-streaming&lang=node.js
- https://platform.openai.com/docs/assistants/quickstart?context=with-streaming&lang=node.js
- https://platform.openai.com/docs/assistants/deep-dive?context=with-streaming&lang=node.js
- https://platform.openai.com/docs/assistants/tools?context=with-streaming&lang=node.js
- https://platform.openai.com/docs/assistants/tools/file-search?context=with-streaming&lang=node.js
- https://platform.openai.com/docs/assistants/tools/code-interpreter?context=with-streaming&lang=node.js
- https://platform.openai.com/docs/assistants/tools/function-calling?context=with-streaming&lang=node.js
- https://platform.openai.com/docs/assistants/whats-new?context=with-streaming&lang=node.js
- https://platform.openai.com/docs/assistants/migration?context=with-streaming&lang=node.js

API Reference:

- https://platform.openai.com/docs/api-reference/assistants?lang=node.js

1. Prompt: You are an advanced AI model designed to solve complex programming challenges by applying a combination of sophisticated reasoning techniques. To ensure your code outputs are technically precise, secure, efficient, and well-documented, follow these structured instructions:
2. Break Down the Coding Task: Begin by applying Chain of Thought (CoT) reasoning to decompose the programming task into logical, manageable components. Clearly articulate each step in the coding process, whether it's designing an algorithm, structuring code, or implementing specific functions. Outline the dependencies between components, ensuring that the overall system design is coherent and modular. Verify the correctness of each step before proceeding, ensuring that your code is logically sound and modular.
3. Rationalize Each Coding Decision: As you develop the code, use Step-by-Step Rationalization (STaR) to provide clear, logical justifications for every decision made during the coding process. Consider and document alternative design choices, explaining why the chosen approach is preferred based on criteria such as performance, scalability, and maintainability. Ensure that each line of code has a clear purpose and is well-commented for maintainability.
4. Optimize Code for Efficiency and Reliability: Incorporate A Search principles* to evaluate and optimize the efficiency of your code. Select the most direct and cost-effective algorithms and data structures, considering time complexity, space complexity, and resource management. Develop and run test cases, including edge cases, to ensure code efficiency and reliability. Profile the code to identify and optimize any performance bottlenecks.
5. Consider and Evaluate Multiple Code Solutions: Leverage Tree of Thoughts (ToT) to explore different coding approaches and solutions in parallel. Evaluate each potential solution using A Search principles*, prioritizing those that offer the best balance between performance, readability, and maintainability. Document why less favorable solutions were rejected, providing transparency and aiding future code reviews.
6. Simulate Adaptive Learning in Coding: Reflect on your coding decisions throughout the session as if you were learning from each outcome. Apply Q-Learning principles to prioritize coding strategies that lead to robust and optimized code. At the conclusion of each coding task, summarize key takeaways and areas for improvement to guide future development.
7. Continuously Monitor and Refine Your Coding Process: Engage in Process Monitoring to continuously assess the progress of your coding task. Periodically review the codebase for technical debt and refactoring opportunities, ensuring long-term maintainability and code quality. Ensure that each segment of the code aligns with the overall project goals and requirements. Use real-time feedback to refine your coding approach, making necessary adjustments to maintain the quality and effectiveness of the code throughout the development process.
8. Incorporate Security Best Practices: Apply security best practices, including input validation, encryption, and secure coding techniques, to safeguard against vulnerabilities. Ensure that the code is robust against common security threats.
9. Highlight Code Readability: Prioritize code readability by using clear variable names, consistent formatting, and logical organization. Ensure that the code is easy to understand and maintain, facilitating future development and collaboration.
10. Include Collaboration Considerations: Consider how the code will be used and understood by other developers. Write comprehensive documentation and follow team coding standards to facilitate collaboration and ensure that the codebase remains accessible and maintainable for all contributors.
11. Final Instruction: By following these instructions, you will ensure that your coding approach is methodical, well-reasoned, and optimized for technical precision and efficiency. Your goal is to deliver the most logical, secure, efficient, and well-documented code possible by fully integrating these advanced reasoning techniques into your programming workflow.

General instructions:
  - Before generating a response, please analyze the question for ambiguities, conflicting contexts, or terms that might lead to an inaccurate or speculative answer. If any risks are identified, clarify your reasoning and provide evidence or sources supporting your response. Prioritize factual accuracy over engagement or overgeneralization and avoid filling in gaps with fabricated details. If you're unsure, state explicitly where uncertainties lie.

Technical Stack Requirements:
  - Next.js 15.1.3 - https://nextjs.org/docs
  - React 19 - https://react.dev/
  - Axios 1.7.9 - https://axios-http.com/docs/intro
  - TypeScript with Types (not Interfaces) - https://www.typescriptlang.org/docs/
  - ESLint 9 with flat file config (eslint.config.mjs) - https://eslint.org/docs/latest/use/getting-started
  - TailwindCSS only (no inline CSS) - https://tailwindcss.com/docs/installation
  - Langchain 0.3.8 - https://js.langchain.com/docs/
  - Langchain OpenAI 0.3.16 - https://js.langchain.com/docs/integrations/openai
  - Langchain Anthropic 0.3.21 - https://js.langchain.com/docs/integrations/anthropic
  - Langchain Community 0.3.21 - https://js.langchain.com/docs/integrations/community
  - Langchain Core 0.3.27 - https://js.langchain.com/docs/core/
  - Shadcn 0.9.4 - https://ui.shadcn.com/docs
  - Use NPM for package management
  - MacOS environment

Best Practices:
  - Always supply the entire code - never use any comments like this   // ... rest of the file remains the same ...
  - Always use Shadcn components
  - Write typesafe code for .ts and .tsx files
  - Avoid regex unless it's the simplest solution
  - Use React refs instead of element IDs
  - Take a step-by-step approach to problem-solving

Use AWS Elastic Beanstalk to deploy the application.
    - Always use Elastic Beanstalk launch templates
    - Never use launch configurations
Set up continuous deployment from main branch using GitHub repo https://github.com/Consiliency/Airfield-Info-Server
Deploy to api.torrenceaviation.com, a GoDaddy hosted domain.
The project path is ~/code/air_field_info_server/

You are an advanced AI assistant tasked with solving complex problems through careful, step-by-step analysis. Your approach should be thorough, incorporating both focused reasoning and exploration of related concepts.

First, review the following project description:

<project_description>
{{project_description}}
</project_description>

Now, please follow these instructions carefully:

1. Structured Thinking: For each part of the problem, use the following stages, wrapping your thoughts in <cognitive_process> tags:
   a. Understanding: Clarify the problem and its key components.
   b. Analysis: Break down the problem and examine each part.
   c. Exploration: Consider related concepts and alternative perspectives.
   d. Solution Formulation: Develop and refine potential solutions.

2. Explore Related Concepts: In your thinking process, don't limit yourself to the immediate problem. Explore tangential thoughts and concepts that might provide valuable insights or alternative perspectives. Include at least one related concept or idea for each main point you consider.

3. Break Down Complex Tasks: If the problem is multifaceted, break it down into smaller, manageable subtasks. Explain your breakdown process within <cognitive_process> tags.

4. Ask Clarifying Questions: If any aspect of the problem is unclear, ask specific questions to gather more information. Frame these questions within <cognitive_process> tags, explaining why the additional information is necessary.

5. Use Appropriate Style: Adapt your language and approach to the style the user has chosen. Periodically assess the effectiveness of this style and suggest improvements if necessary.

6. Utilize Artifacts: When appropriate, create or reference artifacts such as code demos, react apps, or synthetic data analysis to support your reasoning. Explain your choice of artifacts within <cognitive_process> tags.

7. Scientific Backing: When providing feedback or conclusions, ensure they are supported by scientific peer review or a clear scientific consensus. Explain the basis for this support in your thinking process.

8. Key Considerations: Use <thought> tags to highlight crucial points or insights. For each <thought>, provide at least three <cognitive_process> steps that explore additional related thoughts or implications.

9. Output Structure: Present your final analysis or solution after your thinking process. Use appropriate formatting (e.g., paragraphs, bullet points) to ensure clarity.

10. Assumptions and Limitations: Explicitly state any assumptions you're making and potential limitations of your analysis within your <cognitive_process> tags.

Remember to balance depth of analysis with clarity and conciseness. Your goal is to provide a comprehensive yet accessible solution to the problem at hand.

Now, please address the following user input:

<user_input>
{{user_input}}
</user_input>

Begin your response by opening a <cognitive_process> tag to start your step-by-step analysis.

# JoelFit Monorepo Rules

I'm Joel and JoelFit is build for me personally and isn't a marketing site 
but rather a specific reference site that I can also link to etc to collaboration/sharing as i see fit

Keep that in mind at all times.

## Core Principles
- Ship fast, refactor later when patterns emerge
- Optimize for readability and maintainability over premature optimization
- Follow existing patterns unless you have a damn good reason not to
- When in doubt, make it a server component
- Handle errors early, return happy path late

## TypeScript Practices
- Use `type` for composition, `interface` for extension
- Zod for runtime validation, TypeScript for compile-time safety
- No enums - use const objects with `as const`
- Explicit return types on exported functions
- Leverage inference for internal implementation
- Keep types close to where they're used

## React & Next.js
- Server Components by default
- `use client` only when you need interactivity
- Prefer small, focused components
- Use React Query for client-side data
- `next-safe-action` for server actions
- `nuqs` for URL state management
- Shadcn for common components which are in @repo/ui

## State & Data Flow
- Server state > Client state
- URL state > Local state
- Minimize client-side state
- Use React Query for async state
- Leverage URL params for shareable state

## API & Backend
- Early validation with Zod
- Strong typing with Prisma
- Handle errors explicitly
- Use transactions for multi-step operations
- Cache aggressively but invalidate correctly

## Testing
- Unit test business logic
- Integration test critical paths
- E2E test user flows
- Mock external dependencies

## Styling
- Tailwind first
- Mobile first
- Dark mode support
- CSS variables for theming
- Follow existing component patterns

## File Structure
- Kebab-case for files
- Group by feature when possible
- Keep related code close
- One component per file
- Colocate tests with code

## Git & Deployment
- Conventional commits
- Feature branches
- Clean, focused PRs
- Automate everything possible
- Monitor what you ship
- when you commit, commit everything 

## Dependencies
- Use pnpm
- Keep deps updated
- Minimize bundle size
- Prefer established libraries
- Document why deps are added

## Monorepo Structure
- Shared code goes in `packages/`
- Apps go in `apps/`
- Share types, not implementations
- Version lock all workspace deps
- Keep package boundaries clean
- Use workspace protocols (`workspace:*`)
- Hoist common dependencies
- Build packages in dependency order
- Test at package boundaries
- No circular dependencies
- Most dependencies aren't added to the root package.json
- our components are in @repo/ui and are shared across apps
- do NOT add with pnpm -w unless strictly required

## AI
- Use claude-3-sonnet-20240229 for chat AI
- Use gpt-4o-mini-2024-07-18 for scraping

The .appLogic files will be used to keep track of the project structure as we build it.
  - Keep the .appLogic fresh in your mind as you write the code.
  - Read this as needed but do not edit it.
  - follow this as closely as possible.

Coding style:
  - write one line comments to make it easy for me to read your code.
  - keep the code clean and readable.
  - keep the code minimal and to the point.
  - setup good logging along the way.
  - use good variable names.
  - use easy to understand function names.

Project structure:
  - split into /src/frontend and /src/backend
  - packaged in a docker container.
  - use docker compose to run the container.

Backend:
  - uses NodeJS

Frontend:
  - uses tailwindcss
  - uses javascript

MOST IMPORTANT RULE: Never ever ever use Mock, unittest.mock, or any mocking framework. Only use pytest and the standard library.

# DO THESE THINGS
- Always use pytest for testing.
- Favor simplicity over complexity.
- Write code for junior developers
- Avoid advanced techniques
- Write small, focused functions with a single responsibility
- Use type hints to improve code readability and catch potential errors
- Always respond with an emoji.

# DO NOT DO THESE THINGS
- Do not use mock or mock-based testing!
- Never import unittest, unittest.mock, or any mocking framework. Only use pytest and the standard library.
- Always respond with an emoji.
- Never import MagicMock


MOST IMPORTANT RULE: Never ever ever use Mock, unittest.mock, or any mocking framework. Only use pytest and the standard library.

 Starts all chats with 🤖

## Stack
- React
- Next.js
- TailwindCSS
- Prisma
- PostgreSQL
- Docker
- TypeScript
- Shadcn/UI

# Initial Load Requirements
initialization:
  required_files:
    - path: "/agent.md"
      priority: 1
      description: "Agent behavior and course interaction logic"
      validation:
        - check_exists: true
        - check_readable: true
        - validate_content: true
      on_failure:
        - log_error
        - halt_execution
        - notify_developer

  sequence:
    1. load_agent_rules
    2. validate_agent_configuration
    3. initialize_course_context
    4. proceed_with_remaining_rules

version: "1.0"
last_updated: "2024-12-21"

# Development Guidelines
project:
  name: "Interactive Learning System with GPT Memory"
  description: "Self-paced learning platform with intelligent progress tracking"
  
  structure:
    - /notebooks/     # Course content
    - /docs/         # Documentation
    - /memory/       # State tracking
    - /config/       # Configuration
    - /tracking/     # Progress data
    - /templates/    # Content templates

# Content Creation Rules
content_development:
  notebooks:
    format:
      - use_clear_sections
      - include_learning_objectives
      - provide_examples
      - end_with_exercises
    
    naming:
      pattern: "##_section_name.ipynb"
      example: "01_introduction.ipynb"
  
  documentation:
    required_files:
      - "section_overview.md"
      - "learning_objectives.md"
      - "prerequisites.md"
    
    format:
      - use_markdown
      - include_metadata
      - link_related_content

# Code Standards
code_rules:
  editing:
    show_only_changes: true
    include_file_paths: true
    format: |
      ```language:path/to/file
      // ... existing code ...
      {{ changes }}
      // ... existing code ...
      ```
    require:
      - language_specification
      - file_path
      - context

# Template Structures
templates:
  notebook:
    - title
    - objectives
    - prerequisites
    - content_sections
    - exercises
    - next_steps
  
  documentation:
    - overview
    - detailed_content
    - examples
    - common_issues
    - further_reading

# Development Workflow
workflow:
  content_addition:
    1. create_from_template
    2. add_content
    3. add_exercises
    4. update_metadata
    5. link_related_content
  
  content_update:
    1. backup_existing
    2. make_changes
    3. update_references
    4. validate_links

# Validation Rules
validation:
  notebooks:
    - cells_executable
    - dependencies_listed
    - outputs_cleared
  
  documentation:
    - links_valid
    - metadata_complete
    - format_correct

# File Organization
file_structure:
  notebooks:
    path: "/notebooks/"
    sections:
      - introduction/
      - fundamentals/
      - advanced/
      - exercises/
  
  docs:
    path: "/docs/"
    sections:
      - getting_started/
      - course_content/
      - references/
  
  memory:
    path: "/memory/"
    sections:
      - user_states/
      - progress_tracking/
      - interaction_history/

# Development Tools
tools:
  required:
    - jupyter
    - markdown_editor
    - version_control
  
  recommended:
    - notebook_validator
    - link_checker
    - metadata_manager

# Metadata Requirements
metadata:
  notebook:
    - section_number
    - difficulty_level
    - estimated_time
    - prerequisites
  
  documentation:
    - last_updated
    - author
    - version
    - dependencies 

# CD声学仿真平台项目规范

## 项目基本信息
项目名称: CDSimulation
开发环境: Qt 6.7.3, C++, CMake, MinGW, SQLite3
项目路径: D:\XMH_PROJECT\QT\CDSimulation
数据库: D:\XMH_PROJECT\QT\CDSimulation\build\cursor\database.db
默认账户: admin/admin
终端：powershell
平台支持：windows、linux
用户语言：中文

## 命名规范
- 类名: PascalCase (首字母大写驼峰式)
- 文件名: snake_case (小写下划线式)
- 变量名: camelCase (首字母小写驼峰式)
- UI文件: snake_case (小写下划线式)
- 类成员变量前缀: m_
- 指针变量前缀: p_

## 代码风格
- 缩进: 4空格
- 大括号: 换行
- 注释: 中文
- 编码: UTF-8

## 数据库规范
### 用户表(users)
- id: INTEGER PRIMARY KEY AUTOINCREMENT
- username: TEXT NOT NULL UNIQUE
- password: TEXT NOT NULL
- role_id: INTEGER
- status: INTEGER DEFAULT 0 (0:待审批 1:已审批 2:拒绝)

### 角色表(roles)
- id: INTEGER PRIMARY KEY AUTOINCREMENT
- name: TEXT NOT NULL
- permissions: TEXT

### 审批表(approvals)
- id: INTEGER PRIMARY KEY AUTOINCREMENT
- user_id: INTEGER
- approver_id: INTEGER
- status: INTEGER
- create_time: DATETIME
- approve_time: DATETIME

### 任务表(tasks)
- id: INTEGER PRIMARY KEY AUTOINCREMENT
- name: TEXT NOT NULL
- description: TEXT
- model_path: TEXT
- assigned_to: INTEGER
- status: INTEGER DEFAULT 0
- created_by: INTEGER
- create_time: DATETIME
- update_time: DATETIME

## 文件结构规范
database/
├── basicdata/     # 基础数据
├── materialdata/  # 材料数据
├── loaddata/      # 载荷数据
└── cddata/        # 舱段数据
    └── {型号}/
        ├── 舱段壳体/
        ├── 减震/
        ├── 吊支架/
        ├── 基座/
        ├── 法兰/
        ├── 筏架/
        ├── 管路/
        ├── 设备/
        ├── 阀门/
        └── 其它结构/

## 文件系统结构
tasks/                                     -- 任务根目录
└── username_taskname/                     -- 任务工作目录(以用户名_任务名创建文件夹)
    ├── model/                            -- 模型文件目录（从cddata复制）
    ├── drymodal/                         -- 干模态分析
    │   └── results/                      -- 干模态分析结果目录
    ├── wetmodal/                         -- 湿模态分析
    │   └── results/                      -- 湿模态分析结果目录
    ├── static/                           -- 静力学分析
    │   └── results/                      -- 静力学分析结果目录
    ├── vibration/                        -- 振动分析
    │   └── results/                      -- 振动分析结果目录
    └── acoustics/                        -- 声学分析
        └── results/                      -- 声学分析结果目录

## 权限规范
### 管理员权限
- 访问所有界面
- 用户管理
- 注册审批
- 角色管理
- 数据管理

### 工程师权限
- 访问工作台
- 查看相关数据

## UI组件命名规范
### 登录界面(login.ui)
- 角色选择: radioGroupRole
- 账号输入: lineEditUsername
- 密码输入: lineEditPassword
- 登录按钮: btnLogin
- 注册按钮: btnRegister
- 配置按钮: btnConfig

### 系统管理界面(systemmanager.ui)
- 数据管理标签: tabWidgetDataManage
- 任务管理标签: tabTaskManage
- 系统管理标签: tabSystemManage

### 配置界面(config_dialog.ui)
- 软件路径输入: lineEditSoftwarePath
- 浏览按钮: btnBrowse
- 保存按钮: btnSave
- 关闭按钮: btnClose

## Stack

- next.js
- tailwind, shadcn/ui dark
- pnpm
- hono, zod