ai-rules

Enforces architectural constraints by parsing declarative rule files (likely YAML or JSON format) that define project boundaries, forbidden patterns, and allowed libraries. These rules are injected into AI agent prompts or used to validate generated code against a project's governance model, preventing agents from violating established architectural decisions. The system likely maintains a rule registry that can be version-controlled and shared across team members.

Enforces usage of specific UI libraries and design system components by defining allowed component registries and patterns in rule files. When AI agents generate code, the system validates that only approved components are used and that they follow design system conventions (naming, props, composition patterns). This prevents agents from creating custom components or using incompatible libraries that break visual consistency.

Validates generated code against defined architectural patterns (e.g., MVC, layered architecture, dependency injection) and provides repair suggestions when violations are detected. The system likely uses pattern matching or AST analysis to identify violations and can either block generation or suggest corrections. This prevents architectural drift caused by AI agents that don't understand project structure.

Injects project rules and constraints directly into AI agent prompts (system prompts or context windows) so agents generate code that respects boundaries from the start. The system likely formats rules into natural language instructions that agents can understand and follow, reducing the need for post-generation validation. This works by intercepting or augmenting the prompts sent to AI models before code generation.

Manages rule versions and synchronizes them across multiple AI agents and team members, ensuring consistent governance across different tools (Cursor, Windsurf, Copilot). Rules are likely stored in a version-controlled format that can be distributed to team members and integrated into different agent environments. This prevents rule drift where different developers have different constraint sets.

Detects violations of project rules in generated code and produces detailed reports identifying what was violated, where, and why. The system likely uses pattern matching, AST analysis, or semantic analysis to identify violations and generates human-readable reports that developers can act on. Reports may include severity levels, suggested fixes, and links to rule documentation.

Enforces rules about which dependencies and imports are allowed in the codebase, preventing AI agents from introducing unauthorized libraries or creating circular dependencies. The system validates import statements against an allowed dependency list and can detect when agents try to import from forbidden modules. This works by analyzing import/require statements and comparing them against a whitelist or blacklist defined in rules.

Enforces consistent code style and naming conventions (camelCase, PascalCase, snake_case, etc.) across AI-generated code by validating against rules. The system analyzes variable names, function names, class names, and file names to ensure they match project conventions. This prevents stylistic inconsistencies that arise when AI agents generate code without understanding team preferences.

Enforces minimum test coverage and quality standards for AI-generated code by validating that generated functions have corresponding tests and meet coverage thresholds. The system can detect when AI generates code without tests and flag it as a violation. This prevents AI agents from shipping untested code.

Enforces documentation and comment requirements for AI-generated code, ensuring that complex functions, public APIs, and architectural decisions are documented. The system validates that generated code includes JSDoc comments, README updates, or other documentation as defined by rules. This prevents AI from generating undocumented code.