architecture-compliance

1. Classes and Enums

```typescript

// ❌ Prohibited

class GameState { }

enum Direction { UP, DOWN, LEFT, RIGHT }

// ✅ Required

type GameState = { / ... / }

type Direction = 'UP' | 'DOWN' | 'LEFT' | 'RIGHT'

```

2. `any` Type

```typescript

// ❌ Prohibited

function process(data: any) { }

// ✅ Required

function process(data: unknown) {

if (isValidData(data)) {

// Type-safe processing

}

}

```

3. Non-null Assertion (`!`)

```typescript

// ❌ Prohibited

const value = optional!.property

// ✅ Required

const value = optional?.property

if (optional) {

const value = optional.property

}

```

4. Hardcoded User-facing Strings

```typescript

// ❌ Prohibited

Start Game

// ✅ Required

{t('game.start')}

```

5. Interface in React Components

```typescript

// ❌ Prohibited (in React components)

interface Props {

value: string

}

// ✅ Required

type Props = {

value: string

}

```

6. External Imports (outside `/src`)

```typescript

// ❌ Prohibited

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

// ✅ Required

import { util } from '@/utils' // Cross-directory

import { util } from './utils' // Same directory

```

1. Functional Programming

```typescript

// ✅ Pure functions preferred

export const calculateScore = (params: ScoreParams): number => {

// Pure function logic

}

// ❌ Classes not allowed

class ScoreCalculator { }

```

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

```typescript

// ✅ Required for game logic

type Result = { ok: true; value: T } | { ok: false; error: E }

export const placePiece = (

board: Board,

piece: Piece,

position: Position

): Result => {

if (!isValidPosition(board, piece, position)) {

return { ok: false, error: 'INVALID_POSITION' }

}

return { ok: true, value: updatedBoard }

}

```

3. Proper Import Conventions

```typescript

// ✅ 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

```typescript

// ✅ All UI strings use i18n

import { useTranslation } from 'react-i18next'

const { t } = useTranslation()

return

```

6. `useId()` for Dynamic IDs

```typescript

// ❌ Static IDs

// ✅ Dynamic IDs

const id = useId()

```

1. Automated Detection

```bash

# 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
• [ ] Imports follow @/ or ./ conventions
• [ ] Tests are co-located
• [ ] Type aliases instead of interfaces in React

• "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?"

This document contains all prohibited and required patterns inline above.

See .claude/rules/ for additional architectural guidelines.