Architecture Compliance

Architecture Compliance Checker

Automatically verify code compliance with Tetris project architecture rules.

Prohibited Patterns ❌

1. Classes and Enums

// ❌ Prohibited
class GameState { }
enum Direction { UP, DOWN, LEFT, RIGHT }

// ✅ Required
type GameState = { /* ... */ }
type Direction = 'UP' | 'DOWN' | 'LEFT' | 'RIGHT'

2. any Type

// ❌ Prohibited
function process(data: any) { }

// ✅ Required
function process(data: unknown) {
  if (isValidData(data)) {
    // Type-safe processing
  }
}

3. Non-null Assertion (!)

// ❌ Prohibited
const value = optional!.property

// ✅ Required
const value = optional?.property
if (optional) {
  const value = optional.property
}

4. Hardcoded User-facing Strings

// ❌ Prohibited
<button>Start Game</button>

// ✅ Required
<button>{t('game.start')}</button>

5. Interface in React Components

// ❌ Prohibited (in React components)
interface Props {
  value: string
}

// ✅ Required
type Props = {
  value: string
}

6. External Imports (outside /src)

// ❌ Prohibited
import { util } from '../../../utils'

// ✅ Required
import { util } from '@/utils'  // Cross-directory
import { util } from './utils'  // Same directory

Required Patterns ✅

1. Functional Programming

// ✅ Pure functions preferred
export const calculateScore = (params: ScoreParams): number => {
  // Pure function logic
}

// ❌ Classes not allowed
class ScoreCalculator { }

2. Result<T, E> Pattern (Game Logic)

// ✅ Required for game logic
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E }

export const placePiece = (
  board: Board,
  piece: Piece,
  position: Position
): Result<Board, PlacementError> => {
  if (!isValidPosition(board, piece, position)) {
    return { ok: false, error: 'INVALID_POSITION' }
  }
  return { ok: true, value: updatedBoard }
}

3. Proper Import Conventions

// ✅ Cross-directory imports
import { Board } from '@/game/board'
import { Piece } from '@/game/pieces'

// ✅ Same-directory imports
import { helper } from './helper'
import { utils } from './utils'

4. Co-located Tests

src/game/
├── board.ts
├── board.test.ts       # ✅ Co-located
├── pieces.ts
└── pieces.test.ts      # ✅ Co-located

5. Type-safe i18n

// ✅ All UI strings use i18n
import { useTranslation } from 'react-i18next'

const { t } = useTranslation()
return <div>{t('game.title')}</div>

6. useId() for Dynamic IDs

// ❌ Static IDs
<label htmlFor="game-input">

// ✅ Dynamic IDs
const id = useId()
<label htmlFor={id}>

Compliance Check Process

1. Automated Detection

# Check for prohibited classes
rg "^class\s+\w+" src/

# Check for enums
rg "^enum\s+\w+" src/

# Check for any types
rg ":\s*any(\s|;|,|\))" src/

# Check for non-null assertions
rg "\!\." src/

# Check for hardcoded strings
rg '"[A-Z][a-zA-Z\s]{3,}"' src/ui/

2. Manual Review Checklist

• No classes or enums
• No any types
• No non-null assertions (!)
• All UI strings use i18n
• Game logic uses Result<T, E>
• Imports follow @/ or ./ conventions
• Tests are co-located
• Type aliases instead of interfaces in React

When This Skill Activates

• "Review this code"
• "Check if this follows the architecture"
• "Is this implementation correct?"
• "Refactor this to match our patterns"
• "Validate this against our rules"
• "Does this comply with our standards?"

Quick Reference

This document contains all prohibited and required patterns inline above. See .claude/rules/ for additional architectural guidelines.