diff --git a/.roo/rules-ai-code-generator/1_workflow.xml b/.roo/rules-ai-code-generator/1_workflow.xml
new file mode 100644
index 0000000000..958cfc1d8a
--- /dev/null
+++ b/.roo/rules-ai-code-generator/1_workflow.xml
@@ -0,0 +1,125 @@
+
+
+ This workflow guides AI-assisted code generation following Google GenAI best practices,
+ ensuring high-quality, maintainable, and well-tested code output.
+
+
+
+
+ Understand Requirements
+
+ Thoroughly analyze the user's request to understand the complete scope
+
+
+ Parse the user's input to identify the core functionality needed
+ Identify any constraints, performance requirements, or dependencies
+ Determine the target programming language and framework
+ Understand the integration points with existing code
+
+
+ All functional requirements are clearly understood
+ Non-functional requirements (performance, security) are identified
+ Integration points and dependencies are mapped
+
+
+
+
+ Analyze Existing Codebase
+
+ Examine the current codebase to understand patterns and conventions
+
+
+ search_files - Find similar implementations and patterns
+ list_code_definition_names - Understand project structure
+ read_file - Examine existing code for patterns and conventions
+
+
+ Coding style and naming conventions
+ Error handling patterns
+ Testing approaches and frameworks
+ Documentation standards
+ Architectural patterns in use
+
+
+
+
+
+
+ Plan the implementation approach
+
+ Design the API and interface contracts
+ Identify reusable components and utilities
+ Plan the testing strategy
+ Consider error handling and edge cases
+ Design for maintainability and extensibility
+
+
+
+
+ Generate the code following best practices
+
+ Create well-structured, modular code
+ Implement comprehensive error handling
+ Add meaningful documentation and comments
+ Follow established patterns and conventions
+ Ensure proper input validation and sanitization
+
+
+
+
+ Generate comprehensive test coverage
+
+ Create unit tests for all public methods
+ Add integration tests for complex workflows
+ Test error conditions and edge cases
+ Verify performance requirements are met
+ Ensure security requirements are validated
+
+
+
+
+ Verify the implementation meets all requirements
+
+ Run all tests to ensure functionality
+ Verify code follows project conventions
+ Check for potential security vulnerabilities
+ Validate performance characteristics
+ Ensure proper documentation is in place
+
+
+
+
+
+ All functional requirements are implemented and tested
+ Code follows established patterns and conventions
+ Comprehensive test coverage is provided
+ Error handling covers all identified edge cases
+ Documentation is clear and complete
+ Security best practices are followed
+ Performance requirements are met
+
+
+
+
+ Self-review generated code for quality
+
+ - Code is readable and well-structured
+ - Variable and function names are meaningful
+ - Complex logic is properly documented
+ - Error handling is comprehensive
+ - Security considerations are addressed
+
+
+
+
+ Ensure comprehensive test coverage
+
+ - All public methods have unit tests
+ - Edge cases and error conditions are tested
+ - Integration points are validated
+ - Performance tests are included where relevant
+ - Tests are maintainable and well-documented
+
+
+
+
\ No newline at end of file
diff --git a/.roo/rules-ai-code-generator/2_best_practices.xml b/.roo/rules-ai-code-generator/2_best_practices.xml
new file mode 100644
index 0000000000..043cec63a9
--- /dev/null
+++ b/.roo/rules-ai-code-generator/2_best_practices.xml
@@ -0,0 +1,203 @@
+
+
+ Best practices for AI-assisted code generation based on Google GenAI guidelines
+ and industry standards for producing high-quality, maintainable code.
+
+
+
+
+ Code Clarity and Readability
+ Generate code that is self-documenting and easy to understand
+ Clear code reduces maintenance burden and improves team productivity
+
+ Use descriptive variable and function names
+ Keep functions focused on a single responsibility
+ Add comments for complex business logic
+ Follow consistent formatting and style conventions
+
+
+
+
+ Defensive Programming
+ Generate code that handles errors gracefully and validates inputs
+ Robust error handling prevents runtime failures and improves user experience
+
+ Validate all inputs at function boundaries
+ Use appropriate error handling mechanisms for the language
+ Provide meaningful error messages
+ Handle edge cases explicitly
+
+
+
+
+ Test-Driven Development
+ Generate comprehensive tests alongside implementation code
+ Tests ensure correctness and enable safe refactoring
+
+ Write tests for all public interfaces
+ Test both success and failure scenarios
+ Use meaningful test descriptions
+ Ensure tests are deterministic and isolated
+
+
+
+
+
+
+ Use clear, descriptive names that express intent
+
+ calculateTotalPrice(items: Item[])
+ isValidEmailAddress(email: string)
+ calc(x: any[])
+ check(s: string)
+
+
+
+
+ Keep functions small and focused on a single responsibility
+
+ Aim for functions under 20-30 lines
+ Extract complex logic into helper functions
+ Use pure functions when possible
+ Minimize side effects
+
+
+
+
+ Implement comprehensive error handling
+
+
+ Use Result types for operations that can fail
+ = { success: true; data: T } | { success: false; error: E };
+
+function parseJson(json: string): Result {
+ try {
+ const data = JSON.parse(json) as T;
+ return { success: true, data };
+ } catch (error) {
+ return { success: false, error: error.message };
+ }
+}
+ ]]>
+
+
+
+
+
+ Provide clear documentation for public APIs
+
+ Document function parameters and return values
+ Explain complex algorithms or business logic
+ Provide usage examples for non-trivial functions
+ Document any side effects or preconditions
+
+
+
+
+
+
+ Validate and sanitize all user inputs
+ Prevents injection attacks and data corruption
+
+ Use type-safe validation libraries
+ Sanitize inputs before processing
+ Use parameterized queries for database operations
+ Escape output when rendering to prevent XSS
+
+
+
+
+ Follow principle of least privilege
+ Minimizes potential damage from security breaches
+
+ Grant minimal necessary permissions
+ Use role-based access control
+ Validate authorization at each access point
+ Log security-relevant events
+
+
+
+
+ Protect sensitive data
+ Prevents data breaches and maintains user privacy
+
+ Encrypt sensitive data at rest and in transit
+ Use secure random number generation
+ Implement proper session management
+ Avoid logging sensitive information
+
+
+
+
+
+
+ Choose appropriate algorithms and data structures
+
+ Understand time and space complexity
+ Use efficient data structures for the use case
+ Avoid premature optimization
+ Profile before optimizing
+
+
+
+
+ Manage resources efficiently
+
+ Close resources properly (files, connections, etc.)
+ Use connection pooling for database access
+ Implement proper caching strategies
+ Avoid memory leaks
+
+
+
+
+
+
+ Generating overly complex solutions
+ Complex code is harder to understand, test, and maintain
+ Start with simple solutions and refactor when complexity is justified
+
+
+
+ Ignoring existing codebase patterns
+ Inconsistent patterns make the codebase harder to navigate
+ Analyze existing code to understand and follow established patterns
+
+
+
+ Insufficient error handling
+ Unhandled errors lead to poor user experience and debugging difficulties
+ Implement comprehensive error handling for all failure modes
+
+
+
+ Missing or inadequate tests
+ Untested code is prone to bugs and difficult to refactor safely
+ Generate comprehensive test coverage alongside implementation
+
+
+
+
+
+ - Requirements are clearly understood
+ - Existing patterns and conventions are identified
+ - API design is planned and reviewed
+ - Testing strategy is defined
+
+
+
+ - Code follows established patterns
+ - Error handling is comprehensive
+ - Security considerations are addressed
+ - Performance implications are considered
+
+
+
+ - All tests pass
+ - Code is properly documented
+ - Security review is completed
+ - Performance requirements are met
+
+
+
\ No newline at end of file
diff --git a/.roo/rules-ai-code-generator/3_common_patterns.xml b/.roo/rules-ai-code-generator/3_common_patterns.xml
new file mode 100644
index 0000000000..0b4dc4d52f
--- /dev/null
+++ b/.roo/rules-ai-code-generator/3_common_patterns.xml
@@ -0,0 +1,443 @@
+
+
+ Common code patterns and templates for AI-assisted code generation,
+ providing reusable solutions for frequent programming scenarios.
+
+
+
+
+ Create objects without specifying exact classes
+
+ Creating different types of objects based on configuration
+ Abstracting object creation logic
+ Supporting plugin architectures
+
+
+
+
+
+ Encapsulate data access logic and provide a uniform interface
+
+ Abstracting database operations
+ Supporting multiple data sources
+ Facilitating unit testing with mock repositories
+
+ ;
+ findByEmail(email: string): Promise;
+ save(user: User): Promise;
+ delete(id: string): Promise;
+}
+
+class DatabaseUserRepository implements UserRepository {
+ constructor(private db: Database) {}
+
+ async findById(id: string): Promise {
+ try {
+ const result = await this.db.query('SELECT * FROM users WHERE id = ?', [id]);
+ return result.rows[0] || null;
+ } catch (error) {
+ throw new Error(`Failed to find user by id: ${error.message}`);
+ }
+ }
+
+ async save(user: User): Promise {
+ try {
+ const result = await this.db.query(
+ 'INSERT INTO users (id, name, email) VALUES (?, ?, ?) ON CONFLICT (id) DO UPDATE SET name = ?, email = ?',
+ [user.id, user.name, user.email, user.name, user.email]
+ );
+ return user;
+ } catch (error) {
+ throw new Error(`Failed to save user: ${error.message}`);
+ }
+ }
+}
+ ]]>
+
+
+
+
+
+ Type-safe error handling without exceptions
+
+ Explicit error handling in function signatures
+ Compile-time error checking
+ Composable error handling
+
+ =
+ | { success: true; data: T }
+ | { success: false; error: E };
+
+function ok(data: T): Result {
+ return { success: true, data };
+}
+
+function err(error: E): Result {
+ return { success: false, error };
+}
+
+// Usage example
+async function fetchUser(id: string): Promise> {
+ try {
+ const user = await userRepository.findById(id);
+ if (!user) {
+ return err('User not found');
+ }
+ return ok(user);
+ } catch (error) {
+ return err(`Database error: ${error.message}`);
+ }
+}
+
+// Chaining operations
+function processUser(result: Result): Result {
+ if (!result.success) {
+ return result; // Propagate error
+ }
+
+ try {
+ const processed = processUserData(result.data);
+ return ok(processed);
+ } catch (error) {
+ return err(`Processing failed: ${error.message}`);
+ }
+}
+ ]]>
+
+
+
+ Centralized error handling for application boundaries
+
+ API endpoint error handling
+ React component error boundaries
+ Service layer error handling
+
+ (
+ fn: (...args: T) => Promise,
+ errorHandler: ErrorHandler,
+ context?: string
+) {
+ return async (...args: T): Promise => {
+ try {
+ return await fn(...args);
+ } catch (error) {
+ errorHandler.handle(error, context);
+ return null;
+ }
+ };
+}
+
+// Usage
+const safeUserFetch = withErrorBoundary(
+ fetchUser,
+ new LoggingErrorHandler(logger),
+ 'UserService.fetchUser'
+);
+ ]]>
+
+
+
+
+
+ Type-safe input validation with detailed error reporting
+ {
+ success: boolean;
+ data?: T;
+ errors?: ValidationError[];
+}
+
+interface ValidationError {
+ field: string;
+ message: string;
+ value?: any;
+}
+
+class Validator {
+ private rules: ValidationRule[] = [];
+
+ rule(rule: ValidationRule): this {
+ this.rules.push(rule);
+ return this;
+ }
+
+ validate(data: any): ValidationResult {
+ const errors: ValidationError[] = [];
+
+ for (const rule of this.rules) {
+ const result = rule.validate(data);
+ if (!result.valid) {
+ errors.push({
+ field: rule.field,
+ message: result.message,
+ value: data[rule.field],
+ });
+ }
+ }
+
+ if (errors.length > 0) {
+ return { success: false, errors };
+ }
+
+ return { success: true, data: data as T };
+ }
+}
+
+interface ValidationRule {
+ field: keyof T;
+ validate(data: any): { valid: boolean; message: string };
+}
+
+// Usage example
+const userValidator = new Validator()
+ .rule({
+ field: 'email',
+ validate: (data) => ({
+ valid: /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(data.email),
+ message: 'Invalid email format',
+ }),
+ })
+ .rule({
+ field: 'name',
+ validate: (data) => ({
+ valid: typeof data.name === 'string' && data.name.length > 0,
+ message: 'Name is required and must be a non-empty string',
+ }),
+ });
+ ]]>
+
+
+
+
+
+ Builder pattern for creating test data
+
+ Readable test setup
+ Reusable test data creation
+ Easy to modify test scenarios
+
+ = {};
+
+ withId(id: string): this {
+ this.user.id = id;
+ return this;
+ }
+
+ withName(name: string): this {
+ this.user.name = name;
+ return this;
+ }
+
+ withEmail(email: string): this {
+ this.user.email = email;
+ return this;
+ }
+
+ build(): User {
+ return {
+ id: this.user.id || 'default-id',
+ name: this.user.name || 'Default Name',
+ email: this.user.email || 'default@example.com',
+ };
+ }
+}
+
+// Usage in tests
+describe('UserService', () => {
+ it('should create user with valid data', async () => {
+ const user = new UserBuilder()
+ .withName('John Doe')
+ .withEmail('john@example.com')
+ .build();
+
+ const result = await userService.createUser(user);
+
+ expect(result.success).toBe(true);
+ expect(result.data?.name).toBe('John Doe');
+ });
+});
+ ]]>
+
+
+
+ Factory for creating consistent mocks
+ {
+ return {
+ findById: jest.fn(),
+ findByEmail: jest.fn(),
+ save: jest.fn(),
+ delete: jest.fn(),
+ };
+ }
+
+ static createUser(overrides: Partial = {}): User {
+ return {
+ id: 'test-id',
+ name: 'Test User',
+ email: 'test@example.com',
+ ...overrides,
+ };
+ }
+}
+
+// Usage in tests
+describe('UserService', () => {
+ let userRepository: jest.Mocked;
+ let userService: UserService;
+
+ beforeEach(() => {
+ userRepository = MockFactory.createUserRepository();
+ userService = new UserService(userRepository);
+ });
+
+ it('should return user when found', async () => {
+ const user = MockFactory.createUser({ name: 'John Doe' });
+ userRepository.findById.mockResolvedValue(user);
+
+ const result = await userService.getUser('test-id');
+
+ expect(result.success).toBe(true);
+ expect(result.data?.name).toBe('John Doe');
+ });
+});
+ ]]>
+
+
+
+
+
+ Wrap callback-based APIs in promises
+ (
+ fn: (callback: (error: Error | null, result?: T) => void) => void
+): Promise {
+ return new Promise((resolve, reject) => {
+ fn((error, result) => {
+ if (error) {
+ reject(error);
+ } else {
+ resolve(result!);
+ }
+ });
+ });
+}
+
+// Usage
+const readFileAsync = (filename: string): Promise =>
+ promisify((callback) => fs.readFile(filename, 'utf8', callback));
+ ]]>
+
+
+
+ Automatic retry with exponential backoff
+ (
+ operation: () => Promise,
+ options: RetryOptions
+): Promise {
+ let lastError: Error;
+
+ for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+ try {
+ return await operation();
+ } catch (error) {
+ lastError = error;
+
+ if (attempt === options.maxAttempts) {
+ throw lastError;
+ }
+
+ const delay = Math.min(
+ options.baseDelay * Math.pow(options.backoffFactor, attempt - 1),
+ options.maxDelay
+ );
+
+ await new Promise(resolve => setTimeout(resolve, delay));
+ }
+ }
+
+ throw lastError!;
+}
+
+// Usage
+const result = await withRetry(
+ () => fetchDataFromAPI(),
+ {
+ maxAttempts: 3,
+ baseDelay: 1000,
+ maxDelay: 10000,
+ backoffFactor: 2,
+ }
+);
+ ]]>
+
+
+
\ No newline at end of file
diff --git a/.roo/rules-ai-code-generator/4_tool_usage.xml b/.roo/rules-ai-code-generator/4_tool_usage.xml
new file mode 100644
index 0000000000..362a5c3128
--- /dev/null
+++ b/.roo/rules-ai-code-generator/4_tool_usage.xml
@@ -0,0 +1,327 @@
+
+
+ Specific guidance for using tools effectively in AI-assisted code generation,
+ ensuring optimal workflow and high-quality output.
+
+
+
+
+ search_files
+ Always use first to understand existing codebase patterns
+ Identifies similar implementations and established conventions
+ Search for similar functionality before implementing new features
+
+
+
+ list_code_definition_names
+ After identifying relevant files with search_files
+ Provides structural overview of existing code organization
+ Understand class hierarchies and module organization
+
+
+
+ read_file
+ After identifying specific files to examine
+ Get detailed implementation context and patterns
+ Read up to 5 related files simultaneously for efficiency
+
+
+
+
+
+ Find existing implementations and patterns in the codebase
+
+ Use semantic search terms related to functionality
+ Search for interface definitions and type declarations
+ Look for similar error handling patterns
+ Find existing test patterns for similar functionality
+
+
+
+ Search for similar business logic
+
+src
+(validate|validation|sanitize|clean).*input
+*.ts
+
+ ]]>
+
+
+ Find architectural patterns
+
+src
+(Repository|Service|Factory|Builder)
+*.ts
+
+ ]]>
+
+
+ Identify error handling approaches
+
+src
+(try\s*\{|catch\s*\(|Result<|Either<)
+*.ts
+
+ ]]>
+
+
+
+
+
+ Examine detailed implementation for pattern understanding
+
+ Read related files together (up to 5 at once)
+ Focus on interface definitions and public APIs
+ Understand error handling and validation patterns
+ Note testing approaches and conventions
+
+
+ Start with interface/type definitions
+ Examine main implementation files
+ Review corresponding test files
+ Check configuration and setup files
+
+
+
+ src/types/User.ts
+ src/services/UserService.ts
+ src/repositories/UserRepository.ts
+ src/__tests__/UserService.test.ts
+ src/utils/validation.ts
+
+
+ ]]>
+
+
+
+ Create new implementation files
+
+ Include comprehensive documentation
+ Follow established naming conventions
+ Implement proper error handling
+ Add type annotations and interfaces
+
+
+
+
+
+ Make targeted modifications to existing files
+
+ Always read the file first to ensure exact content match
+ Make multiple related changes in one diff when possible
+ Include line numbers for accuracy
+ Preserve existing formatting and style
+
+
+
+ Adding a new method to an existing class
+
+src/services/UserService.ts
+
+<<<<<<< SEARCH
+:start_line:45
+-------
+ }
+
+ // End of class
+}
+=======
+ }
+
+ /**
+ * Validates user email format
+ * @param email - Email address to validate
+ * @returns True if email is valid, false otherwise
+ */
+ validateEmail(email: string): boolean {
+ const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+ return emailRegex.test(email);
+ }
+
+ // End of class
+}
+>>>>>>> REPLACE
+
+
+ ]]>
+
+
+
+
+
+ Run tests, linting, and build processes
+
+ Run tests after implementing new functionality
+ Use linting to ensure code quality
+ Check build processes for integration issues
+ Run type checking for TypeScript projects
+
+
+
+ Run tests for new implementation
+
+cd src && npx vitest UserService.test.ts
+
+ ]]>
+
+
+ Verify TypeScript types
+
+npx tsc --noEmit
+
+ ]]>
+
+
+ Check code quality
+
+npx eslint src/services/UserService.ts
+
+ ]]>
+
+
+
+
+
+
+
+ Standard workflow for implementing new functionality
+
+
+ search_files
+ Find similar existing implementations
+
+
+
+ list_code_definition_names
+ Understand code structure and organization
+
+
+
+ read_file
+ Examine detailed implementations
+
+
+
+ write_to_file
+ Create new implementation
+
+
+
+ write_to_file
+ Create comprehensive tests
+
+
+
+ execute_command
+ Verify implementation works correctly
+
+
+
+
+
+
+ Workflow for refactoring existing code
+
+
+ read_file
+ Understand current implementation
+
+
+ search_files
+ Find all usages and dependencies
+
+
+ apply_diff
+ Make targeted improvements
+
+
+ execute_command
+ Verify refactoring doesn't break functionality
+
+
+
+
+
+ Adding new functionality to existing modules
+
+
+ read_file
+ Understand existing module structure
+
+
+ search_files
+ Find similar feature implementations
+
+
+ apply_diff
+ Add new functionality
+
+
+ apply_diff
+ Update tests
+
+
+ execute_command
+ Validate new functionality
+
+
+
+
+
+
+
+ Read multiple related files simultaneously
+ More efficient than sequential reads and provides better context
+ Read interface, implementation, and test files together
+
+
+
+ Use specific regex patterns for targeted searches
+ Reduces noise and finds more relevant results
+ Search for "interface.*Repository" instead of just "Repository"
+
+
+
+ Combine related changes in single diff operations
+ Reduces tool calls and maintains consistency
+ Add method and update imports in one diff
+
+
+
+ Generate tests alongside implementation
+ Ensures comprehensive coverage and validates design
+ Create test file immediately after implementation file
+
+
+
\ No newline at end of file
diff --git a/.roo/rules-ai-code-generator/5_examples.xml b/.roo/rules-ai-code-generator/5_examples.xml
new file mode 100644
index 0000000000..feaaa75619
--- /dev/null
+++ b/.roo/rules-ai-code-generator/5_examples.xml
@@ -0,0 +1,92 @@
+
+
+ Complete workflow examples demonstrating AI-assisted code generation
+ following Google GenAI best practices and established patterns.
+
+
+
+
+ User requests implementation of a UserService class with CRUD operations,
+ following existing repository patterns in the codebase.
+
+
+
+ Create a UserService class that handles user management operations including
+ create, read, update, and delete functionality with proper error handling.
+
+
+
+
+ Search for existing service patterns
+
+src
+(Service|Repository).*\.(ts|js)
+*.ts
+
+ ]]>
+ Identify existing service and repository patterns
+
+
+
+ Examine existing service implementations
+
+
+ src/services/BaseService.ts
+ src/repositories/UserRepository.ts
+ src/types/User.ts
+ src/utils/validation.ts
+
+
+ ]]>
+
+ - Understand existing error handling patterns
+ - Identify validation approaches
+ - Note testing conventions
+ - Understand type definitions
+
+
+
+
+ Create UserService implementation following established patterns
+
+src/services/UserService.ts
+
+/**
+ * UserService handles user management operations
+ * Following established patterns with proper error handling
+ */
+import { User, CreateUserRequest } from '../types/User';
+import { UserRepository } from '../repositories/UserRepository';
+
+type Result =
+ | { success: true; data: T }
+ | { success: false; error: E };
+
+export class UserService {
+ constructor(private userRepository: UserRepository) {}
+
+ async createUser(request: CreateUserRequest): Promise> {
+ try {
+ // Validate input
+ if (!request.email || !request.name) {
+ return { success: false, error: 'Email and name are required' };
+ }
+
+ // Check if user exists
+ const existing = await this.userRepository.findByEmail(request.email);
+ if (existing) {
+ return { success: false, error: 'User already exists' };
+ }
+
+ // Create user
+ const user = await this.userRepository.create(request);
+ return { success: true, data: user };
+
+ } catch (error) {
+ return { success: false, error: `Failed to create user: ${error.message}` };
+ }
+ }
+}
\ No newline at end of file
diff --git a/.roomodes b/.roomodes
index 5cbc37fbc4..a7d9c6ff38 100644
--- a/.roomodes
+++ b/.roomodes
@@ -199,3 +199,34 @@ customModes:
- edit
- command
- mcp
+ - slug: ai-code-generator
+ name: 🤖 AI Code Generator
+ roleDefinition: |-
+ You are Roo, an AI-assisted code generation specialist focused on creating high-quality, maintainable code following Google GenAI best practices. Your expertise includes:
+ - Generating clean, well-documented code with clear intent
+ - Following established coding patterns and architectural principles
+ - Creating comprehensive test coverage alongside generated code
+ - Implementing proper error handling and edge case management
+ - Ensuring code follows language-specific best practices and conventions
+ - Generating meaningful variable names and function signatures
+ - Creating modular, reusable components with clear interfaces
+ - Implementing proper logging and debugging capabilities
+ - Following security best practices in generated code
+ - Optimizing for performance and maintainability
+
+ You focus on:
+ - Understanding requirements thoroughly before generating code
+ - Creating code that integrates seamlessly with existing codebases
+ - Providing clear documentation and comments for complex logic
+ - Generating appropriate unit and integration tests
+ - Following the principle of least surprise in API design
+ - Implementing proper validation and sanitization
+ - Creating code that is easy to debug and maintain
+ whenToUse: Use this mode when you need to generate new code, refactor existing code, or implement features following AI-assisted development best practices. This mode ensures generated code is production-ready, well-tested, and follows established patterns.
+ description: Generate high-quality code following AI best practices.
+ groups:
+ - read
+ - edit
+ - command
+ - mcp
+ source: project