coding_standards.mouse

4. Standards & Quality Assurance: Coding Standards (Mouse Protocol)

Rationale: Defines the non-negotiable quality, security, and maintainability expectations for all code produced or modified by the Agent. Strict adherence ensures consistency, reduces errors, enhances collaboration, and aligns with professional software development practices. The Agent is expected to internalize these standards and apply them proactively and rigorously.

4.1 Code Quality & Conventions (Mandatory Adherence)

• Project-Specific & Language Idiomatic Standards:
  • The Agent MUST meticulously adhere to any project-specific coding standards, linting rules (e.g., ESLint, Pylint, Checkstyle, RuboCop, SwiftLint), and formatting guidelines (e.g., Prettier, Black, Spotless, gofmt, rustfmt) defined and accessible within the project (e.g., via .eslintrc.js, prettier.config.js, pyproject.toml, checkstyle.xml, .swiftlint.yml).
  • Agent Action: Before coding, Agent MUST scan for such configuration files. If found, Agent configures its internal generation process to comply strictly. If not found, Agent MUST use widely accepted community best practices and idiomatic conventions for the specific language and its version, prioritizing clarity, security, and maintainability. Agent logs which standards (project or default) are being applied.
• Clarity, Readability & Simplicity (KISS Principle):
  • Code MUST be exceptionally clear, self-documenting where possible, and easily understandable by another human developer or a future instance of the Agent.
  • Employ meaningful, descriptive, and consistent naming conventions for variables, functions, classes, modules, etc. (e.g., camelCase for JS/Java variables/functions, PascalCase for classes, snake_case for Python variables/functions).
  • Avoid overly complex, nested, or "clever" logic if simpler, more straightforward alternatives exist that achieve the same functional outcome (refer to @mouse/standards/guiding_software_principles.mouse.mdc#kiss).
• Maintainability & Modularity (SRP, DRY Principles):
  • Code MUST be structured for ease of future modification, extension, and debugging.
  • Follow modular design principles: Create small, focused functions/methods/classes that perform a single, well-defined task (Single Responsibility Principle - SRP).
  • Aggressively avoid code duplication (Don't Repeat Yourself - DRY). Abstract common logic into reusable functions, classes, or modules. Reference @mouse/standards/guiding_software_principles.mouse.mdc.
• Commenting & Documentation (See also @mouse/standards/documentation_standards.mouse.mdc):
  • Provide clear, concise comments for complex logic, non-obvious design decisions, workarounds, or sections of code that have known limitations (e.g., // HACK: Temporary workaround for API bug XYZ-123. TODO: Remove when fixed.).
  • Public APIs (functions, classes, methods exposed for external use) MUST have comprehensive docstrings/API comments detailing purpose, parameters, return values, and exceptions.
• Error Handling & Resilience (Robustness):
  • Implement robust, specific error handling for all anticipated failure conditions (e.g., invalid inputs, I/O errors, API failures, unmet preconditions).
  • Use language-specific exception handling mechanisms correctly. Catch specific exceptions rather than generic ones, unless intentionally re-throwing with added context.
  • Provide meaningful error messages that help in diagnosing the problem. Log errors appropriately (see logging standards).
  • Consider graceful degradation or fallback mechanisms where appropriate.
• Security Best Practices (Critical - Principle of Least Privilege, Secure by Design):
  • Agent MUST be actively mindful of common security vulnerabilities relevant to the language, framework, and context (e.g., OWASP Top 10: SQL Injection, XSS, CSRF, Insecure Deserialization, Broken Access Control, etc.).