TRUST 5 Quality Framework

def calculate_discount(price: float, discount_rate: float) -> float:
    """Calculate discounted price.
 
    Args:
        price: Original price (0 or more)
        discount_rate: Discount rate (0.0 ~ 1.0)
 
    Returns:
        Discounted price
 
    Raises:
        ValueError: For invalid input values
    """
    if price < 0:
        raise ValueError("Price cannot be less than 0")
    if not 0 <= discount_rate <= 1:
        raise ValueError("Discount rate must be between 0.0 and 1.0")
    return price * (1 - discount_rate)
 
 
# Tests verify both normal and exception cases
def test_calculate_discount_normal():
    assert calculate_discount(10000, 0.1) == 9000
    assert calculate_discount(5000, 0.5) == 2500
    assert calculate_discount(0, 0.5) == 0
 
def test_calculate_discount_invalid_price():
    with pytest.raises(ValueError, match="Price cannot"):
        calculate_discount(-1000, 0.1)
 
def test_calculate_discount_invalid_rate():
    with pytest.raises(ValueError, match="Discount rate"):
        calculate_discount(10000, 1.5)

# Bad: Can't tell what it does from the name
def calc(d, r):
    return d * (1 - r)
 
# Good: Can understand the role just by reading the name
def calculate_discounted_price(original_price: float, discount_rate: float) -> float:
    """Calculate price discounted by discount_rate from original_price."""
    return original_price * (1 - discount_rate)

# Unified error handling pattern
class AppError(Exception):
    """Application base error"""
    def __init__(self, message: str, code: int = 500):
        self.message = message
        self.code = code
 
class NotFoundError(AppError):
    """Resource not found"""
    def __init__(self, resource: str, id: str):
        super().__init__(f"{resource} '{id}' not found", code=404)
 
class ValidationError(AppError):
    """Input validation failed"""
    def __init__(self, field: str, reason: str):
        super().__init__(f"'{field}' validation failed: {reason}", code=400)
 
# Use same pattern in all services
def get_user(user_id: str) -> User:
    user = user_repository.find_by_id(user_id)
    if not user:
        raise NotFoundError("User", user_id)
    return user

# Bad: SQL Injection vulnerability
def get_user(username: str) -> dict:
    query = f"SELECT * FROM users WHERE username = '{username}'"
    return db.execute(query)
 
# Good: Safe with parameterized queries
def get_user(username: str) -> dict:
    query = "SELECT * FROM users WHERE username = %s"
    return db.execute(query, (username,))

# Structure: <type>(<scope>): <description>
# Examples:
 
# Add new feature
$ git commit -m "feat(auth): Add JWT login API"
 
# Fix bug
$ git commit -m "fix(auth): Fix token expiration time calculation error"
 
# Refactor
$ git commit -m "refactor(auth): Separate auth logic into AuthService"
 
# Security improvement
$ git commit -m "security(db): Prevent SQL Injection with parameterized queries"

# Run auto fix
> /moai fix
 
# Repeat auto fix until complete
> /moai loop

constitution:
  # Enable TRUST 5 quality verification
  enforce_quality: true
 
  # Target test coverage
  test_coverage_target: 85
 
  # LSP quality gate settings
  lsp_quality_gates:
    enabled: true
 
    plan:
      require_baseline: true # Capture baseline at Plan start
 
    run:
      max_errors: 0 # Error allowance in Run phase: 0
      max_type_errors: 0 # Type error allowance: 0
      max_lint_errors: 0 # Lint error allowance: 0
      allow_regression: false # No regression from baseline
 
    sync:
      max_errors: 0 # Error allowance in Sync phase: 0
      max_warnings: 10 # Warning allowance: max 10
      require_clean_lsp: true # Require clean LSP state
 
    cache_ttl_seconds: 5 # LSP diagnostic cache time
    timeout_seconds: 3 # LSP diagnostic timeout