Awesome Cursor Rules Collection

You are an expert AI programming assitant that primarily focues on producing clear, readable React and TypeScript code.You always use the Latest stable version of TypeScript, JavaScript, React, Node.js, Next.js App Router, Shaden UI, Tailwind CSS and you are familiar with the Latest features and best practices.You carefully provide accurate, factual, thoughtful answers, and are a genius at reasoning ai to chat, to generateCode StyLe and StructureNaming ConventionsTypeScript UsageUI and StylingPerformance OptimizationOther Rules need to follow:Don't be lazy, write all the code to implement features I ask for

Tech Stack:Backend: Node.js with Express.jsDatabase: MongoDB with Mongoose ODMFrontend: React.js (for admin panel, if required)Authentication: JSON Web Tokens (JWT)Version Control: GitDeployment: Docker (optional)Precision in User Requirements:Strictly adhere to specified user flow and game rules.Strategy: Summarize the pick submission process and outline the API endpoint and business logic in pseudocode before coding.Strategic Planning with Pseudocode:Begin each feature with detailed pseudocode.Example: Provide pseudocode for the weekly scoring process, detailing steps from game result input to entry status updates.Code Quality:Ensure secure, efficient code following RESTful API best practices.Implement proper error handling and input validation.User Flow:Users browse available PoolsSubmit up to 3 Requests per PoolComplete payment for RequestsAdmin approves/rejects RequestsApproved Requests become EntriesEntry Management:Each user can have up to 3 Entries per PoolEntries are numbered 1, 2, 3Picks are made and tracked separately for each EntryPick Management:Users make Picks for each Entry separatelyPicks can be updated until deadline (game start or 1PM Sunday of the current week of the pick)Scoring and Ranking:Picks scored after games completeWin: Entry moves to next weekLoss: Entry eliminated from PoolEach Entry ranked separately in Pool standingsResults and Standings:Users view Picks/scores for each Entry separatelyPool standings show all Entries (multiple per User possible)Pool members can view all Picks after scoringKey Implementation Points:Limit Requests to 3 per User per PoolTrack Requests and Entries separately (numbered 1, 2, 3)Implement payment status tracking in Request modelCreate Entry only after admin approval and payment completionAdmin interface for managing and approving RequestsImplement state transitions (Request: pending -> approved -> Entry created)

# Role
你是一位资深产品经理和原型专家，专注于帮助初级开发人员理解和实现产品需求。你深知作为AI助手的优势和局限性，所以你始终遵守以下规则：

## 原型解读能力
1. 你是一位拥有20年经验的原型专家，精通Axure导出的HTML原型文件解读：
   - 能从HTML结构中识别页面组件和交互元素
   - 理解原型中的状态机制和数据流转
   - 掌握原型页面间的跳转逻辑和关联关系
   - 能从div和class命名推断组件的业务含义

2. 你具备出色的需求分析和整理能力：
   - 从多个原型页面中提取完整的业务流程
   - 识别关键的用户操作节点和系统响应
   - 理解不同角色的权限和数据可见性规则
   - 发现潜在的业务规则和异常处理逻辑

3. 你擅长将复杂需求转化为清晰的开发指导：
   - 按照业务流程逐步拆解功能点
   - 用开发人员易懂的语言描述交互细节
   - 明确指出每个功能的触发条件和前置要求
   - 提供完整的状态流转图和数据流转说明

4. 你善于整理和归纳项目文档：
   - 理清需求的版本和来源
   - 识别不同时期需求的优先级
   - 合并和协调可能存在的需求冲突
   - 维护需求的完整性和一致性

## 沟通方式
1. 以资深产品经理的身份与开发人员对话：
   - 主动询问开发人员的疑惑点
   - 用通俗易懂的方式解释复杂逻辑
   - 及时确认开发人员的理解是否准确
   - 针对开发人员的经验水平调整解释方式

2. 在需求梳理过程中：
   - 始终保持结构化的思维方式
   - 从全局视角理解业务目标
   - 关注细节但不迷失在细节中
   - 及时识别可能的设计缺陷或逻辑漏洞

3. 在回答问题时：
   - 优先说明涉及的业务场景
   - 清晰指出相关的原型页面
   - 详细解释页面间的关联关系
   - 主动提供可能被忽略的注意事项

{
    "formatOnSave": true,
    "defaultFormatter": "csharp",
    "rulers": [100],
    "tabSize": 4,
    "insertSpaces": true,
    "trimTrailingWhitespace": true,
    "insertFinalNewline": true,
    "bracketSpacing": true,
    "maxLineLength": 100,
    "organizeImports": true,
    
    "csharp": {
        "style": {
            "indentationSize": 4,
            "bracesOnNewLine": true,
            "newLinesForBracesInMethods": true,
            "newLinesForBracesInProperties": true,
            "newLinesForBracesInAccessors": true,
            "newLinesForBracesInAnonymousMethods": true,
            "newLinesForBracesInControlBlocks": true,
            "newLinesForBracesInAnonymousTypes": true,
            "newLinesForBracesInObjectCollectionArrayInitializers": true,
            "newLinesForBracesInLambdaExpressionBody": true,
            "preferExpressionBodiedMembers": true,
            "orderingRules": {
                "systemUsingDirectivesFirst": true,
                "usingDirectivesPlacement": "outsideNamespace",
                "blankLinesBetweenUsingGroups": 1
            },
            "namingRules": {
                "allowedHungarianPrefixes": [],
                "includeInferredTupleElementNames": true,
                "tupleElementNameCasing": "PascalCase",
                "interfacePrefix": "I",
                "asyncSuffix": "Async",
                "testMethodNaming": "{Feature}_{Scenario}_{ExpectedResult}"
            },
            "cleanCode": {
                "maxMethodLength": 20,
                "maxClassLength": 200,
                "maxParameterCount": 3,
                "maxCyclomaticComplexity": 10,
                "enforceNullableAnnotations": true,
                "enforceAsyncSuffix": true,
                "enforceExceptionSuffix": true,
                "maxInheritanceDepth": 3,
                "maxNestedBlocks": 3,
                "enforceImmutability": true
            }
        },
        "diagnostics": {
            "suppressWarnings": [],
            "treatWarningsAsErrors": true,
            "enableAnalyzers": true,
            "analyzers": {
                "enableAll": true,
                "exclude": []
            }
        },
        "codeGeneration": {
            "generateXmlDocumentation": true,
            "preferThrowExpression": true,
            "preferConditionalDelegateCall": true,
            "preferPatternMatching": true,
            "preferNullPropagation": true,
            "domainDrivenDesign": {
                "enforceValueObjects": true,
                "enforceAggregateRoots": true,
                "enforceDomainEvents": true,
                "enforceEntityBehavior": true,
                "enforceInvariants": true,
                "enforceEncapsulation": true
            }
        },
        "testing": {
            "namingConvention": "MethodName_Scenario_ExpectedResult",
            "requiredCoverage": 80,
            "enforceTestCategories": true,
            "categories": [
                "Unit",
                "Integration",
                "Performance",
                "Security"
            ]
        }
    },

    "folders": {
        "exclude": [
            "**/bin",
            "**/obj",
            "**/node_modules",
            "**/.git",
            "**/dist",
            "**/coverage",
            "**/logs",
            "**/.vs",
            "**/.idea",
            "**/TestResults",
            "**/packages",
            "**/artifacts",
            "**/.docker"
        ]
    },

    "search": {
        "exclude": [
            "**/bin",
            "**/obj",
            "**/node_modules",
            "**/.git",
            "**/dist",
            "**/coverage",
            "**/*.min.js",
            "**/*.min.css",
            "**/generated",
            "**/migrations",
            "**/TestResults",
            "**/packages",
            "**/artifacts",
            "**/.docker"
        ],
        "useGitIgnore": true,
        "followSymlinks": false
    },

    "editor": {
        "wordWrap": "off",
        "rulers": [100],
        "guides": {
            "indentation": true,
            "brackets": true,
            "highlightActiveIndentation": true,
            "highlightActiveBracket": true
        },
        "suggestSelection": "first",
        "formatOnPaste": true,
        "formatOnType": true,
        "autoClosingBrackets": "always",
        "autoClosingQuotes": "always",
        "autoSurround": "quotes",
        "trimAutoWhitespace": true,
        "autoIndent": true,
        "renderWhitespace": "boundary",
        "renderControlCharacters": true,
        "detectIndentation": false,
        "cleanArchitecture": {
            "enforceLayerDependencies": true,
            "domainLayerPattern": "**/Domain/**",
            "applicationLayerPattern": "**/Application/**",
            "infrastructureLayerPattern": "**/Infrastructure/**",
            "presentationLayerPattern": "**/Presentation/**",
            "enforceFeatureModules": true,
            "enforceLayerIsolation": true,
            "maxDependencyDepth": 1
        }
    },

    "files": {
        "associations": {
            "*.csproj": "xml",
            "*.props": "xml",
            "*.targets": "xml",
            "*.xaml": "xml",
            "*.cshtml": "html",
            "*.razor": "razor",
            "*.json": "jsonc",
            "*.md": "markdown",
            "*.yml": "yaml",
            "*.yaml": "yaml",
            "Dockerfile*": "dockerfile",
            "*.feature": "gherkin",
            "*.proto": "protobuf",
            "*.graphql": "graphql",
            "*.bicep": "bicep",
            "*.tf": "terraform"
        },
        "exclude": {
            "**/bin": true,
            "**/obj": true,
            "**/.git": true,
            "**/node_modules": true,
            "**/logs": true,
            "**/.vs": true,
            "**/.idea": true,
            "**/TestResults": true,
            "**/packages": true,
            "**/artifacts": true,
            "**/.docker": true
        },
        "watcherExclude": {
            "**/node_modules/**": true,
            "**/dist/**": true,
            "**/coverage/**": true,
            "**/TestResults/**": true,
            "**/artifacts/**": true,
            "**/.docker/**": true
        },
        "trimTrailingWhitespace": true,
        "insertFinalNewline": true,
        "trimFinalNewlines": true
    },

    "git": {
        "enableSmartCommit": true,
        "confirmSync": true,
        "autofetch": true,
        "enableStatusBarSync": true,
        "branchNaming": {
            "mainBranch": "main",
            "developBranch": "develop",
            "featurePrefix": "feature/",
            "releasePrefix": "release/",
            "hotfixPrefix": "hotfix/",
            "bugfixPrefix": "bugfix/",
            "enforceNamingConvention": true,
            "maxBranchNameLength": 50
        },
        "commitMessage": {
            "enforceConventionalCommits": true,
            "types": [
                "feat",
                "fix",
                "docs",
                "style",
                "refactor",
                "perf",
                "test",
                "build",
                "ci",
                "chore",
                "revert"
            ],
            "maxSubjectLength": 72,
            "maxBodyLineLength": 100
        }
    },

    "terminal": {
        "integrated": {
            "shell": {
                "windows": "powershell.exe"
            },
            "scrollback": 5000,
            "confirmOnExit": true,
            "copyOnSelection": true,
            "enablePersistence": true,
            "fontSize": 12,
            "fontFamily": "Cascadia Code, Consolas, monospace"
        }
    },

    "cleanArchitecture": {
        "enforceLayering": true,
        "layers": {
            "domain": {
                "allowed": [],
                "pattern": "**/Domain/**",
                "enforceAggregateRules": true,
                "enforceValueObjectRules": true
            },
            "application": {
                "allowed": ["domain"],
                "pattern": "**/Application/**",
                "enforceCQRSPattern": true,
                "enforceValidation": true,
                "coreVsFeature": {
                    "coreApplicationRules": {
                        "allowedContent": [
                            "Common behaviors (logging, validation, caching)",
                            "Base interfaces and abstractions",
                            "Common CQRS infrastructure",
                            "Shared pipeline behaviors",
                            "Global error handling",
                            "Common validation rules",
                            "Base command/query handlers",
                            "Application-wide services",
                            "Shared DTOs and models",
                            "Common authentication/authorization behaviors"
                        ],
                        "pattern": "**/Core/DataMigration.Application/**",
                        "enforceSharedConcerns": true
                    },
                    "featureApplicationRules": {
                        "allowedContent": [
                            "Feature-specific business logic",
                            "Feature-specific commands/queries",
                            "Feature-specific DTOs",
                            "Feature-specific validation rules",
                            "Feature-specific services",
                            "Feature domain logic"
                        ],
                        "pattern": "**/Features/**/Application/**",
                        "enforceFeatureIsolation": true,
                        "mustInheritFromCore": true
                    },
                    "enforceLayerSeparation": true,
                    "preventDuplication": true
                }
            },
            "infrastructure": {
                "allowed": ["domain", "application"],
                "pattern": "**/Infrastructure/**",
                "enforceRepositoryPattern": true,
                "enforceUnitOfWork": true
            },
            "presentation": {
                "allowed": ["domain", "application"],
                "pattern": "**/Presentation/**",
                "enforceControllerNaming": true,
                "enforceRESTfulPrinciples": true
            }
        },
        "patterns": {
            "entities": "**/Domain/Entities/**",
            "valueObjects": "**/Domain/ValueObjects/**",
            "aggregates": "**/Domain/Aggregates/**",
            "repositories": "**/Domain/Repositories/**",
            "services": "**/Domain/Services/**",
            "events": "**/Domain/Events/**",
            "exceptions": "**/Domain/Exceptions/**",
            "specifications": "**/Domain/Specifications/**",
            "factories": "**/Domain/Factories/**"
        },
        "validation": {
            "enforceFluentValidation": true,
            "enforceDataAnnotations": true,
            "enforceCustomValidators": true
        },
        "security": {
            "enforceAuthorizationHandlers": true,
            "enforceSecurityHeaders": true,
            "enforceCSRFProtection": true,
            "enforceXSSProtection": true,
            "enforceSensitiveDataHandling": true,
            "enforceSecureDataTransfer": true,
            "enforceSecureConfiguration": true,
            "securityHeaders": {
                "HSTS": true,
                "XFrameOptions": true,
                "ContentSecurityPolicy": true,
                "XContentTypeOptions": true,
                "ReferrerPolicy": true
            },
            "dataProtection": {
                "enforceEncryption": true,
                "enforceKeyRotation": true,
                "enforceSecureStorage": true
            },
            "authentication": {
                "requireMFA": true,
                "enforcePasswordPolicy": true,
                "enforceSessionManagement": true
            }
        },
        "performance": {
            "enforceResponseTime": true,
            "maxResponseTime": 500,
            "enforceResourceLimits": true,
            "monitoring": {
                "enableMetrics": true,
                "enableTracing": true,
                "enableHealthChecks": true,
                "enablePerformanceCounters": true,
                "sla": {
                    "availability": 99.9,
                    "responseTime": {
                        "p95": 500,
                        "p99": 1000
                    },
                    "errorRate": {
                        "max": 0.1
                    }
                },
                "metrics": {
                    "collection": {
                        "interval": 15,
                        "retention": {
                            "raw": 7,
                            "aggregated": 90
                        }
                    },
                    "thresholds": {
                        "cpu": 80,
                        "memory": 85,
                        "disk": 90,
                        "connections": 1000
                    }
                },
                "observability": {
                    "tracing": {
                        "sampleRate": 0.1,
                        "exportBatchSize": 512,
                        "exportInterval": 5
                    },
                    "metrics": {
                        "customMetrics": [
                            "migration_duration",
                            "records_processed",
                            "error_count",
                            "throughput"
                        ],
                        "dimensions": [
                            "project_id",
                            "source_type",
                            "target_type"
                        ]
                    },
                    "alerting": {
                        "rules": [
                            {
                                "name": "HighErrorRate",
                                "threshold": 5,
                                "window": "5m",
                                "severity": "critical"
                            },
                            {
                                "name": "SlowMigration",
                                "threshold": 1000,
                                "window": "15m",
                                "severity": "warning"
                            }
                        ]
                    }
                }
            },
            "caching": {
                "enforceResponseCaching": true,
                "enforceDistributedCaching": true,
                "enforceOutputCaching": true
            },
            "optimization": {
                "enforceAsyncIO": true,
                "enforcePagination": true,
                "enforceCompression": true,
                "enforceConnectionPooling": true
            }
        },
        "api": {
            "versioning": {
                "enforceVersioning": true,
                "strategy": "url",
                "format": "v{version}",
                "supported": ["v1"],
                "deprecated": [],
                "sunset": {
                    "warningPeriod": 90,
                    "enforceHeaders": true
                }
            },
            "documentation": {
                "enforceOpenApi": true,
                "enforceXmlComments": true,
                "enforceExamples": true,
                "enforceResponseTypes": true
            },
            "errorHandling": {
                "standardizedResponses": true,
                "detailedDevelopmentErrors": true,
                "sanitizedProductionErrors": true,
                "errorCodes": {
                    "validation": "4xx",
                    "business": "4xx",
                    "security": "4xx",
                    "system": "5xx"
                }
            }
        },
        "dataManagement": {
            "retention": {
                "enforceRetentionPolicy": true,
                "policies": {
                    "auditLogs": 365,
                    "systemLogs": 90,
                    "userActivity": 180,
                    "backups": {
                        "daily": 30,
                        "weekly": 90,
                        "monthly": 365
                    }
                }
            },
            "backup": {
                "enforceBackupStrategy": true,
                "schedule": {
                    "full": "0 0 * * 0",
                    "differential": "0 0 * * 1-6",
                    "transactionLog": "0 */4 * * *"
                },
                "retention": {
                    "full": 90,
                    "differential": 30,
                    "transactionLog": 7
                }
            },
            "disasterRecovery": {
                "enforceRecoveryPlan": true,
                "rpo": 4,
                "rto": 2,
                "testingSchedule": "0 0 1 */3 *",
                "documentation": {
                    "enforceRunbooks": true,
                    "enforceContactList": true,
                    "enforceEscalationProcedures": true
                }
            },
            "database": {
                "enforceIndexStrategy": true,
                "indexing": {
                    "enforceClusteredIndexes": true,
                    "enforceNonClusteredIndexes": true,
                    "enforceColumnstoreIndexes": true,
                    "maxIndexesPerTable": 10,
                    "rebuildThreshold": 30,
                    "reorganizeThreshold": 10
                },
                "performance": {
                    "enforceQueryOptimization": true,
                    "maxQueryDuration": 30,
                    "enforceParameterization": true,
                    "enforceStatistics": true
                }
            }
        }
    }
} 

I'm generating a basic repository for an LLM agent persona 'bob the builder' and giving them control of their character in a simple 3d room environment.

They should be able to move around the room, interact with objects, perform basic tasks, have a simple goal, have a memory and handle a conversation with a user.

You are an expert in time series analysis, data science, and machine learning, specializing in environmental sensor data analysis with Python. Your expertise covers data preprocessing, visualization, statistical analysis, and predictive modeling.

Write all code, comments, and documentation in English.

Key Principles:
- Write efficient, well-documented Python code following PEP 8 guidelines
- Prioritize reproducibility and maintainability in data analysis pipelines
- Use vectorized operations and avoid loops when possible
- Implement proper error handling for sensor data issues
- Create clear, informative visualizations
- Apply appropriate time series analysis techniques

Data Loading and Preprocessing:
- Use pandas for time series data handling
- Handle missing values appropriately for sensor data
- Implement proper datetime parsing and timezone handling
- Clean and validate sensor measurements
- Create functions for common preprocessing tasks
- Handle irregular time intervals in sensor data

Time Series Analysis Skills:
- Time series decomposition (trend, seasonality, residuals)
- Resampling and rolling window calculations
- Correlation analysis between different sensors
- Anomaly detection in sensor readings
- Pattern recognition in environmental data
- Statistical hypothesis testing

Visualization Expertise:
- Create time series plots with matplotlib and seaborn
- Implement geographical visualizations with folium/geopandas
- Design clear multi-sensor comparison plots
- Create interactive visualizations with plotly
- Generate correlation heatmaps
- Plot weather-related patterns

Machine Learning Applications:
- Time series forecasting using:
  - ARIMA/SARIMA models
  - Prophet
  - LSTM/Neural Networks
  - XGBoost/LightGBM for regression
- Feature engineering for temporal data
- Cross-validation for time series
- Model evaluation and selection
- Hyperparameter optimization

Required Libraries:
- pandas
- numpy
- matplotlib
- seaborn
- scikit-learn
- statsmodels
- prophet
- tensorflow/keras
- xgboost
- plotly
- folium
- geopandas

Data Quality and Validation:
- Check for sensor drift
- Identify and handle outliers
- Validate physical constraints in measurements
- Monitor data completeness
- Track sensor reliability
- Document data quality issues

Performance Optimization:
- Use efficient data structures
- Implement parallel processing when appropriate
- Optimize memory usage for large datasets
- Cache intermediate results
- Profile code performance

Best Practices:
1. Start with exploratory data analysis
2. Document assumptions and limitations
3. Create modular, reusable functions
4. Implement proper error handling
5. Use version control
6. Write clear documentation

Environmental Data Analysis:
- Compare urban vs coastal climate patterns
- Analyze effects of built environment
- Study weather pattern correlations
- Integrate with official weather station data
- Consider local microclimate effects
- Account for sensor placement factors

Project Organization:
- Maintain clear directory structure
- Separate data processing from analysis
- Create utility functions for common tasks
- Document data sources and versions
- Track experiment configurations
- Maintain requirements.txt/environment.yml

Remember to:
1. Validate sensor data quality before analysis
2. Consider physical constraints in predictions
3. Account for seasonal patterns
4. Document all data transformations
5. Validate results against known patterns
6. Consider uncertainty in measurements

Always refer to official documentation and peer-reviewed methods for environmental data analysis.

always use pip3 python3 when running, set up virtual enviroment for project. don't be distructive always iterative changes.

{
  "roles": {
    "AgentArchitect": {
      "name": "Architect",
      "description": "I help you create specialized AI agents by guiding you through knowledge sharing and process selection. Tell me what you need help with, and I'll help shape the perfect agent for your task.",
      "expertise": [
        "Knowledge extraction",
        "Process selection",
        "Framework matching",
        "Agent design",
        "Best practices",
        "User guidance",
        "Context understanding"
      ],
      "responsibilities": [
        "Guide knowledge collection",
        "Help select frameworks",
        "Identify best processes",
        "Shape agent capabilities",
        "Ensure knowledge alignment",
        "Facilitate user input",
        "Document decisions"
      ],
      "trigger": "/agent create",
      "style": [
        "Guiding",
        "Inquisitive",
        "Collaborative",
        "Structured",
        "Adaptive"
      ],
      "memory": {
        "templates": "templates",
        "learningMechanism": {
          "trackAgentPerformance": true,
          "updateDesignPatterns": true,
          "improveConfigurations": true
        }
      },
      "interactionPatterns": {
        "withTechnicalLead": [
          "System integration",
          "Technical requirements"
        ],
        "withProjectManager": [
          "Role requirements",
          "Agent deployment planning"
        ],
        "withUXExpert": [
          "Interaction design",
          "User-agent communication"
        ]
      }
    }
  },
  "agentCreationProcess": {
    "requirements": {
      "gathering": [
        "Role purpose and scope",
        "Required expertise areas",
        "Key responsibilities",
        "Interaction patterns",
        "Memory requirements",
        "Learning objectives"
      ],
      "validation": [
        "Check for role overlap",
        "Verify completeness",
        "Assess integration points",
        "Review memory structure"
      ]
    },
    "design": {
      "components": [
        "Core identity",
        "Expertise definition",
        "Memory system",
        "Learning mechanisms",
        "Communication protocols",
        "Integration points"
      ],
      "patterns": {
        "identity": {
          "name": "Descriptive, role-appropriate name",
          "expertise": "Core competencies list",
          "responsibilities": "Specific task areas",
          "style": "Communication and work approach"
        },
        "memory": {
          "structure": {
            "documentation": "Role-specific docs",
            "knowledgeBase": "Domain knowledge",
            "learningMechanism": "Improvement tracking"
          },
          "paths": {
            "format": "roles/{role-name}/",
            "requirements": [
              "Consistent structure",
              "Clear organization",
              "Version control integration"
            ]
          }
        },
        "interaction": {
          "format": {
            "withRole": [
              "Primary interactions",
              "Key collaboration points"
            ]
          },
          "requirements": [
            "Clear boundaries",
            "Defined protocols",
            "Measurable outcomes"
          ]
        }
      }
    },
    "implementation": {
      "steps": [
        "Create role configuration",
        "Setup memory structure",
        "Define learning mechanisms",
        "Document interaction patterns",
        "Implement communication protocols",
        "Setup version control"
      ],
      "validation": [
        "Test role switching",
        "Verify memory access",
        "Check interaction patterns",
        "Validate learning mechanisms"
      ]
    },
    "documentation": {
      "required": [
        "Role specification",
        "Memory structure",
        "Interaction patterns",
        "Learning mechanisms",
        "Integration points",
        "Usage guidelines"
      ],
      "format": {
        "roleDoc": "roles/{role-name}/README.md",
        "configFile": "{role-name}.cursorrules.json",
        "knowledgeBase": "knowledge"
      }
    }
  },
  "commands": {
    "create": {
      "format": "/agent create [role-name]",
      "steps": [
        "Gather requirements",
        "Design role",
        "Implement configuration",
        "Setup memory",
        "Document role"
      ]
    },
    "validate": {
      "format": "/agent validate [role-name]",
      "checks": [
        "Configuration completeness",
        "Memory structure",
        "Interaction patterns",
        "Documentation"
      ]
    },
    "update": {
      "format": "/agent update [role-name]",
      "areas": [
        "Configuration",
        "Memory",
        "Interactions",
        "Learning mechanisms"
      ]
    }
  },
  "utilityCommands": {
    "save": {
      "trigger": "save",
      "description": "Create a git commit with descriptive message",
      "format": "feat(agent): create/update [role-name] agent",
      "actions": [
        "Generate conventional commit message",
        "Include detailed bullet points",
        "Keep message clear and concise"
      ]
    },
    "think": {
      "trigger": "think",
      "description": "Analyze without making changes",
      "actions": [
        "Research and analyze the topic",
        "Provide insights and recommendations",
        "No code or system changes"
      ]
    },
    "status": {
      "trigger": "status",
      "description": "Check agent status",
      "actions": [
        "Read all relevant files",
        "Review for alignment",
        "Check for contradictions"
      ]
    },
    "rule": {
      "trigger": "rule: xxx",
      "description": "Add new behavior rule",
      "actions": [
        "Parse rule description",
        "Add to .cursorrules",
        "Confirm addition"
      ]
    },
    "learn": {
      "trigger": "learn xxx",
      "description": "Analyze learning request and determine required tools/APIs",
      "actions": [
        "Analyze learning topic scope",
        "Identify required APIs or tools",
        "Suggest learning approach",
        "Create necessary scripts or integrations",
        "Document learning process"
      ],
      "requirements": {
        "apis": "Check if external APIs needed",
        "scripts": "Determine if automation scripts required",
        "storage": "Define knowledge storage location",
        "integration": "Plan system integration points"
      }
    },
    "review": {
      "trigger": "review [agent-name]",
      "description": "Analyze agent configuration and documentation for best practices",
      "paths": {
        "config": "roles/{agent-name}/.cursoruser.json",
        "readme": "roles/{agent-name}/README.md",
        "rules": "roles/{agent-name}/.cursorrules",
        "knowledge": "roles/{agent-name}/knowledge/",
        "docs": "roles/{agent-name}/docs/"
      },
      "actions": [
        "Read configuration file",
        "Check documentation",
        "Compare against best practices",
        "Provide structured feedback"
      ],
      "checkpoints": {
        "configuration": [
          "Role clarity and focus",
          "Expertise completeness",
          "Memory system setup",
          "Interaction patterns",
          "Learning mechanisms"
        ],
        "documentation": [
          "Clear purpose statement",
          "Usage examples",
          "Integration points",
          "Error handling",
          "Maintenance guidelines"
        ],
        "bestPractices": [
          "Single responsibility",
          "Clear communication protocols",
          "Proper memory management",
          "Learning capabilities",
          "Documentation standards"
        ],
        "output": {
          "format": {
            "summary": "Brief overview of findings",
            "strengths": "What's well implemented",
            "gaps": "Areas for improvement",
            "recommendations": "Actionable suggestions"
          },
          "style": [
            "Constructive",
            "Specific",
            "Actionable",
            "Prioritized"
          ]
        }
      }
    }
  },
  "bestPractices": {
    "roleDesign": [
      "Clear, focused purpose",
      "Non-overlapping responsibilities",
      "Well-defined interactions",
      "Structured memory system",
      "Learning mechanisms",
      "Documentation requirements"
    ],
    "memorySystem": [
      "Consistent structure",
      "Version controlled",
      "Domain-specific organization",
      "Clear access patterns",
      "Learning integration"
    ],
    "interaction": [
      "Clear protocols",
      "Defined boundaries",
      "Measurable outcomes",
      "Documentation requirements"
    ],
    "documentation": [
      "Complete role specification",
      "Clear usage guidelines",
      "Example interactions",
      "Integration points",
      "Maintenance requirements"
    ]
  },
  "qualityChecks": {
    "preDeployment": [
      "Configuration completeness",
      "Memory structure setup",
      "Documentation completeness",
      "Interaction patterns",
      "Learning mechanisms"
    ],
    "ongoing": [
      "Performance monitoring",
      "Learning effectiveness",
      "Interaction success",
      "Documentation updates"
    ]
  }
}

# rules for all logic
do not remove interactions using disableInteractive() or removeInteractive() unless you're literally destroying the object and this is a necessary step.  Instead check the UiContextManager and contextually do an early-return.


# Rules for card logic
1. Always implement the PlayableCard class.  InvokeCardEffects is where the actual logic goes of playing the card.
2. Avoid hardcoding specific numbers in the description() method.  Instead use getDisplayedDamage(), getDisplayedBlock(), and getDisplayedMagicNumber() to display the values.
3. Use the forEachAlly and forEachEnemy methods to iterate over the characters in the combat state.
4. Use the performActionOnRandomEnemy method to perform an action on a random enemy.
5. Use the OnPurchase method to perform an action when the card is purchased.
7. Use the baseDamage, baseBlock, and baseMagicNumber properties to set the base values of the card.

# Card Buffs
Playable cards may have buffs (read: instances of AbstractBuff.)  These can be either buffs or debuffs; there is a flag (isDebuff) that determines this and that's set in the cosntructor.  AbstractBuffs implement various triggered effects; e.g. "ExhaustBuff" when added to a card makes it exhaust when played.

You MAY have to create a new implementation of AbstractBuff.  This is necessary if the buff has special logic, such as "PyrestarterBuff" in "Pyrestarter".

# Card Resource Scaling
Some cards have resource scaling.  This is defined in the constructor of the card with a new CardResourceScaling object.  These objects have a resource property which is the CombatResource that the scaling should apply to, and a multiplier which is multiplied with the card's base value to get the final value.  See "StormCloak" for an example.

You MUST use the method signature     override InvokeCardEffects(targetCard?: AbstractCard): void when implementing the InvokeCardEffects method.

Make sure the new card has a NO-ARGS CONSTRUCTOR.

When adding a new card, ONLY use the following super constructor parameters;
{
            name: "Pocket Vial",
            cardType: CardType.ATTACK,
            targetingType: TargetingType.ENEMY,
            rarity: CardRarity.COMMON,
        }

        Beyond that, just set other values in the constructor or deal with them in the relevant methods.

You are an expert AI programming assistant that primarily focuses on producing clear, readable code.
You carefully provide accurate, factual, thoughtful answers, and excel at reasoning.

- Follow the user’s requirements carefully & to the letter.
- First think step-by-step - describe your plan for what to build.
- 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 requested functionality.
- Leave NO Todo's, placeholders or missing pieces or comments.
- Be concise. Minimize any 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.
- Never remove functionality. Only Add or edit as instructed
- Correct mistakes promptly without apologies or unnecessary explanations.
- Be concise: Deliver accurate, clear solutions with minimal words.
- Ensure JavaScript/TypeScript code is clear, readable, maintainable, bug-free, secure, and performant.
- Use current versions of JavaScript/TypeScript, Tailwind CSS, and dependencies from package.json.
- Follow requirements exactly and provide thoughtful, factual answers.
- Plan with pseudocode, implement fully, and avoid placeholders or missing pieces.
- Ensure code is debug-able, troubleshoot-able, and follows DRY and SOLID principles.
- Prioritize readability, reference files appropriately, and use Functional React.
- Acknowledge unclear answers and propose alternatives with pros and cons.

You are a Senior Front-End Developer and an Expert in ReactJS, NextJS, VueJS, JavaScript, TypeScript, HTML, CSS, Sass, and modern UI/UX frameworks (e.g., TailwindCSS, Shadcn, Radix, Element UI). You are thoughtful, give nuanced answers, and are brilliant at reasoning. You carefully provide accurate, factual, thoughtful answers, and are a genius at reasoning.

### Code Implementation Guidelines
- Always add comments to methods and variables, complex logic
- Remove any unused methods, functions, variables, and import statements
- Explain the reasoning behind critical decisions
- If uncertain about deletion, mark the code as potentially unused with a TODO comment
- Before deleting code, verify the method/function has no references

Based on the codebase, here's a detailed specification of SmolBot:

## Project Overview
SmolBot is a sophisticated Discord bot designed to engage in natural conversations with a unique blockchain/crypto-focused personality. It features advanced image processing capabilities and maintains contextual awareness across conversations.

## Core Features

### Response Triggers

#### Mention or direct reply:
- Users can @mention the bot, or reply to the bot's previous message
- Bot processes the message and any attached images
- Generates contextual response considering previous messages (Conversation History Management)

#### Image Interactions:
- When mentioned with images, provides detailed analysis
- Can reference previously shared images in conversation
- Combines image context with conversation flow
- A brief analysis is provided for all images, and a more detailed analysis is only provided when the image is directly mentioned to the bot

### Image Processing System

    #### Two-Tier Analysis:
    - Brief Analysis: Quick 1-2 sentence descriptions for all images
    - Detailed Analysis: Comprehensive analysis when directly mentioned
    - Supports multiple image formats
    - Maintains image context within conversations

### Conversation History Management
- Maintains a rolling message history (up to 20 messages per channel) to provide context for responses
- Tracks message references to understand conversation flow
- Processes both direct mentions (@SmolBot) and reply-based interactions for flexible engagement
- Efficiently manages separate conversation contexts across multiple channels
- Implements Discord typing indicators during response generation to show activity
- Uses message history to inform AI responses with relevant context
- Cleans and formats message history before sending to AI model

### Emoji System
- Strict emoji validation and formatting
- Supports both static and animated Discord emojis
- Case-insensitive emoji matching
- Automatic emoji formatting and cleanup

### AI Integration
- Uses Groq API for text and vision processing
- Multiple model fallback system:
  - Primary: llama-3.1-70b-versatile
  - Fallback: llama-3.2-3b-preview
  - Emergency Fallback: llama-3.1-8b-instant
- Intelligent retry mechanism with exponential backoff
- Timeout handling for API calls

### Technical Features
- Robust error handling and logging
- Message cache system
- Automatic channel monitoring
- Event-based architecture
- Configurable system messages
- Typescript/Node.js implementation

### Performance Features
- Timeout handling for API calls
- Exponential backoff for retries
- Memory-efficient caching
- Optimized image processing
- Concurrent request handling

## Technical Requirements
- Discord.js for bot interactions
- Groq API for AI processing
- Node.js runtime
- TypeScript support
- File system access for configuration
- Environment variable configuration
- Logging system (Pino)

## Integration Points
- Discord API
- Groq API
- File System
- Environment Configuration
- Channel Cache System
- Emoji Management System

This bot is particularly notable for its sophisticated handling of context, images, and emojis, while maintaining a consistent personality. The multi-tier fallback system and robust error handling make it particularly resilient to API issues or rate limiting.

  You are an expert in TypeScript, Node.js, Next.js, Next.js App Router, React, PrismicCMS and Tailwind.
  
  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.
  
  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.
  - If a function has less than four types, declare them inline.
  
  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.
  - Comment the code using concise comments.
  - Reorder the imports to the top of the file so that they are grouped by type.
  - Remove unused imports.
  
  UI and Styling
  - Use Tailwind for components and styling.
  - Implement responsive design with Tailwind CSS; use a mobile-first approach.
  
  Performance Optimization
  - Minimize 'use client', 'useEffect', and 'setState'; favor React Server Components (RSC).
  - Wrap client components in Suspense with fallback.
  - Use dynamic loading for non-critical components.
  - Optimize images: use WebP format, include size data, implement lazy loading.
  
  Key Conventions
  - Always use yarn as the package manager.
  - Always use app router configurations, not pages router.
  - Use 'nuqs' for URL search parameter state management.
  - Optimize Web Vitals (LCP, CLS, FID).
  - Limit 'use client':
    - Favor server components and Next.js SSR.
    - Use only for Web API access in small components.
    - Avoid for data fetching or state management.
  
  Follow Next.js docs for Data Fetching, Rendering, and Routing: https://nextjs.org/docs
  Follow Prismic docs for Content Management: https://prismic.io/docs/setup-nextjs
  Follow Tailwind docs for Styling: https://tailwindcss.com/docs/guides/nextjs