Merge remote-tracking branch 'origin/main' - resolved conflicts in rock-paper-scissors page

Author: chrisreddington

.github/instructions/mcp-server.instructions.md

@@ -145,7 +145,7 @@ Implement consistent difficulty levels across all games:
 ```typescript
 export function calculateTicTacToeMove(
   gameState: TicTacToeGameState,
-  difficulty: 'easy' | 'medium' | 'hard' = 'medium'
+  difficulty: Difficulty = 'medium'
 ): TicTacToeMove {
   const validMoves = getValidMoves(gameState)
 

.github/instructions/shared-library.instructions.md

@@ -140,6 +140,89 @@ export function getGameDisplayName(type: GameType): string {
 }
 ```
 
+## Constants and Common Values
+
+### Centralized Constants and Derived Types
+**Types are derived from constants using `as const` assertions - constants are the single source of truth:**
+
+```typescript
+// ✅ Constants define the source of truth
+export const DIFFICULTIES = ['easy', 'medium', 'hard'] as const
+export const GAME_TYPES = ['tic-tac-toe', 'rock-paper-scissors'] as const
+export const PLAYER_IDS = { HUMAN: 'player1', PLAYER2: 'player2', AI: 'ai' } as const
+
+// ✅ Types are derived from constants
+export type Difficulty = typeof DIFFICULTIES[number]
+export type GameType = typeof GAME_TYPES[number] 
+export type PlayerId = typeof PLAYER_IDS[keyof typeof PLAYER_IDS]
+
+// ✅ Import the derived types
+import type { Difficulty, GameType } from '@turn-based-mcp/shared'
+
+// ❌ Don't define duplicate union types
+export type Difficulty = 'easy' | 'medium' | 'hard'  // This duplicates the constants!
+```
+
+### Available Constants
+Key constants provided by the shared library:
+
+```typescript
+// Constants with derived types
+export const GAME_TYPES = ['tic-tac-toe', 'rock-paper-scissors'] as const
+export const DIFFICULTIES = ['easy', 'medium', 'hard'] as const
+export const PLAYER_IDS = { HUMAN: 'player1', PLAYER2: 'player2', AI: 'ai' } as const
+export const GAME_STATUSES = ['waiting', 'playing', 'finished'] as const
+
+// Derived types (auto-generated from constants)
+export type GameType = typeof GAME_TYPES[number]
+export type Difficulty = typeof DIFFICULTIES[number]
+export type PlayerId = typeof PLAYER_IDS[keyof typeof PLAYER_IDS]
+export type GameStatus = typeof GAME_STATUSES[number]
+
+// Default values
+export const DEFAULT_PLAYER_NAME = 'Player'
+export const DEFAULT_AI_DIFFICULTY: Difficulty = 'medium'
+
+// UI display configuration
+export const DIFFICULTY_DISPLAY = {
+  easy: { emoji: '😌', label: 'Easy' },
+  medium: { emoji: '🎯', label: 'Medium' },
+  hard: { emoji: '🔥', label: 'Hard' }
+} as const
+```
+
+### Type Guards and Utilities
+Use provided validation functions that work with the constants:
+
+```typescript
+// Type guards (check against the constant arrays)
+export function isSupportedGameType(gameType: string): gameType is GameType
+export function isValidDifficulty(difficulty: string): difficulty is Difficulty
+export function isValidPlayerId(playerId: string): playerId is PlayerId
+
+// Display helpers
+export function getDifficultyDisplay(difficulty: Difficulty)
+```
+
+### Architecture Benefits
+This approach ensures:
+- **Single source of truth**: Constants define what values are valid
+- **Type safety**: TypeScript derives exact types from the constant values
+- **Runtime validation**: Type guards check against the same arrays used to derive types
+- **Maintainability**: Add a new difficulty by updating one constant array
+
+### Testing Constants
+For mocking and test data, use shared testing utilities:
+
+```typescript
+// Test data from shared/src/testing/
+import { 
+  mockTicTacToeGameState, 
+  mockRPSGameState,
+  createMockGameSession 
+} from '@turn-based-mcp/shared/testing'
+```
+
 ## Testing Infrastructure
 
 ### Test Database Utilities

.github/instructions/testing.instructions.md

@@ -31,6 +31,33 @@ Follow these testing patterns for the turn-based games platform:
   })
   ```
 
+## Shared Testing Utilities
+
+**Use centralized mock data and test utilities from the shared package:**
+
+```typescript
+// ✅ Import shared testing utilities
+import { 
+  mockTicTacToeGameState, 
+  mockRPSGameState,
+  createMockGameSession,
+  setupTestDatabase,
+  clearTestDatabase 
+} from '@turn-based-mcp/shared/testing'
+
+// ✅ Use shared constants in tests
+import { DIFFICULTIES, GAME_TYPES } from '@turn-based-mcp/shared'
+
+// ❌ Don't recreate mock data locally
+const localMockGameState = { /* duplicated data */ }  // Use shared mocks instead!
+```
+
+**Available shared testing utilities:**
+- Mock game states: `mockTicTacToeGameState`, `mockRPSGameState`
+- Factory functions: `createMockGameSession`, `createMockPlayer`
+- Database utilities: `setupTestDatabase`, `clearTestDatabase`, `teardownTestDatabase`
+- Type assertions and validation helpers
+
 ## Component Testing
 
 - Always render components with realistic props

.github/instructions/typescript.instructions.md

@@ -15,6 +15,37 @@ Follow these TypeScript patterns for consistent, type-safe code:
 - Use barrel exports (`index.ts`) for clean imports
 - Re-export shared types from `@turn-based-mcp/shared`
 
+### Shared Types and Constants
+**Always import types derived from shared constants - don't duplicate union types:**
+
+```typescript
+// ✅ Import types derived from constants
+import type { Difficulty, GameType, PlayerId } from '@turn-based-mcp/shared'
+import { DIFFICULTIES, DEFAULT_AI_DIFFICULTY, GAME_TYPES, PLAYER_IDS } from '@turn-based-mcp/shared'
+
+// ✅ Use the imported types
+const [aiDifficulty, setAiDifficulty] = useState<Difficulty>('medium')
+const playerIds: PlayerId[] = Object.values(PLAYER_IDS)
+
+// ❌ Don't define duplicate union types
+type Difficulty = 'easy' | 'medium' | 'hard'  // This duplicates shared constants!
+type PlayerId = 'player1' | 'player2' | 'ai'  // Use the derived type instead!
+```
+
+**Key principle: Types are derived from constants using `as const` assertions:**
+```typescript
+// In shared/src/constants/game-constants.ts
+export const DIFFICULTIES = ['easy', 'medium', 'hard'] as const
+export type Difficulty = typeof DIFFICULTIES[number]  // 'easy' | 'medium' | 'hard'
+```
+
+**Common types available from shared package:**
+- `Difficulty` - AI difficulty levels (derived from `DIFFICULTIES`) 
+- `GameType` - Supported game types (derived from `GAME_TYPES`)
+- `PlayerId` - Player identifiers (derived from `PLAYER_IDS`)
+- `GameStatus` - Game state values (derived from `GAME_STATUSES`)
+- Game-specific interfaces: `TicTacToeGameState`, `RPSGameState`, etc.
+
 ### Interface Design
 - Use interfaces for object shapes and component props
 - Include JSDoc comments for complex properties

mcp-server/package.json

@@ -2,12 +2,12 @@
   "name": "@turn-based-mcp/mcp-server",
   "version": "1.0.0",
   "description": "MCP server for turn-based games AI opponent",
-  "main": "dist/index.js",
+  "main": "dist/server.js",
   "type": "module",
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "start": "node dist/index.js",
+    "start": "node dist/server.js",
     "clean": "rm -rf dist",
     "type-check": "tsc --noEmit",
     "test": "vitest run",

mcp-server/src/ai/rock-paper-scissors-ai.ts

@@ -1,8 +1,7 @@
-import type { RPSGameState, RPSMove, RPSChoice } from '@turn-based-mcp/shared'
+import type { RPSGameState, RPSMove, RPSChoice, Difficulty } from '@turn-based-mcp/shared'
 import { RockPaperScissorsGame } from '@turn-based-mcp/shared'
 
 export type Strategy = 'random' | 'adaptive' | 'pattern'
-export type Difficulty = 'easy' | 'medium' | 'hard'
 
 /**
  * AI opponent for Rock Paper Scissors with multiple strategic approaches

mcp-server/src/ai/tic-tac-toe-ai.ts

@@ -1,8 +1,6 @@
-import type { TicTacToeGameState, TicTacToeMove } from '@turn-based-mcp/shared'
+import type { TicTacToeGameState, TicTacToeMove, Difficulty } from '@turn-based-mcp/shared'
 import { TicTacToeGame } from '@turn-based-mcp/shared'
 
-export type Difficulty = 'easy' | 'medium' | 'hard'
-
 /**
  * AI opponent for Tic-Tac-Toe with configurable difficulty levels
  * 

mcp-server/src/index.ts

@@ -1,28 +1,11 @@
 /**
  * HTTP client utilities for communicating with the web API
+ * 
+ * This module provides higher-level API functions for the MCP server
+ * while using shared HTTP utilities to eliminate code duplication.
  */
 
-const WEB_API_BASE = process.env.WEB_API_BASE || 'http://localhost:3000'
-
-export async function httpGet(url: string): Promise<any> {
-  const response = await fetch(url)
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`)
-  }
-  return response.json()
-}
-
-export async function httpPost(url: string, data: any): Promise<any> {
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(data)
-  })
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`)
-  }
-  return response.json()
-}
+import { httpGet, httpPost, WEB_API_BASE } from '@turn-based-mcp/shared'
 
 /**
  * Generic game state fetcher for resources

mcp-server/src/utils/http-client.ts

@@ -1,28 +1,10 @@
 /**
  * Vitest setup for mcp-server package tests
  * 
- * Sets up test database before all tests and cleans up after
+ * Uses shared test setup utilities to ensure consistent database setup
  */
 
-import { setupTestDatabase, teardownTestDatabase } from '@turn-based-mcp/shared'
-import { beforeAll, afterAll } from 'vitest'
+import { setupStandardTestDatabase } from '@turn-based-mcp/shared'
 
-// Setup test database before all tests
-beforeAll(async () => {
-  try {
-    await setupTestDatabase(true) // Use in-memory database for speed
-  } catch (error) {
-    console.error('Failed to setup test database:', error)
-    throw error
-  }
-})
-
-// Cleanup test database after all tests
-afterAll(async () => {
-  try {
-    await teardownTestDatabase()
-  } catch (error) {
-    console.error('Failed to teardown test database:', error)
-    // Don't throw here to avoid masking other test failures
-  }
-})
+// Setup standard test database using shared utility
+setupStandardTestDatabase()