v0.7.1 client readline removed for cross-platform compatibility with wasm, client logic fix fixes and refactor

internal/client/command/auth.go

@@ -0,0 +1,168 @@
+// FILE: lixenwraith/chess/internal/client/command/auth.go
+package command
+
+import (
+	"bufio"
+	"chess/internal/client/api"
+	"chess/internal/client/display"
+	"chess/internal/client/session"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func (r *Registry) registerAuthCommands() {
+	r.Register(&Command{
+		Name:        "register",
+		ShortName:   "r",
+		Description: "Register a new user",
+		Usage:       "register",
+		Handler:     registerHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "login",
+		ShortName:   "l",
+		Description: "Login with credentials",
+		Usage:       "login",
+		Handler:     loginHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "logout",
+		ShortName:   "o",
+		Description: "Clear authentication",
+		Usage:       "logout",
+		Handler:     logoutHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "whoami",
+		ShortName:   "i",
+		Description: "Show current user",
+		Usage:       "whoami",
+		Handler:     whoamiHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "user",
+		ShortName:   "e",
+		Description: "Set user ID manually",
+		Usage:       "user <userId>",
+		Handler:     setUserHandler,
+	})
+}
+
+func registerHandler(s *session.Session, args []string) error {
+	scanner := bufio.NewScanner(os.Stdin)
+	c := s.GetClient().(*api.Client)
+
+	display.Print(display.Yellow, "Username: ")
+	scanner.Scan()
+	username := strings.TrimSpace(scanner.Text())
+
+	password, err := readPassword(display.Yellow + "Password: " + display.Reset)
+	if err != nil {
+		return err
+	}
+
+	display.Print(display.Yellow, "Email (optional): ")
+	scanner.Scan()
+	email := strings.TrimSpace(scanner.Text())
+
+	resp, err := c.Register(username, password, email)
+	if err != nil {
+		return err
+	}
+
+	s.SetAuthToken(resp.Token)
+	s.SetCurrentUser(resp.UserID)
+	s.SetUsername(resp.Username)
+	c.SetToken(resp.Token)
+
+	display.Println(display.Green, "Registered successfully")
+	fmt.Printf("User ID: %s\n", resp.UserID)
+	fmt.Printf("Username: %s\n", resp.Username)
+
+	return nil
+}
+
+func loginHandler(s *session.Session, args []string) error {
+	scanner := bufio.NewScanner(os.Stdin)
+	c := s.GetClient().(*api.Client)
+
+	display.Print(display.Yellow, "Username or Email: ")
+	scanner.Scan()
+	identifier := strings.TrimSpace(scanner.Text())
+
+	password, err := readPassword(display.Yellow + "Password: " + display.Reset)
+	if err != nil {
+		return err
+	}
+
+	resp, err := c.Login(identifier, password)
+	if err != nil {
+		return err
+	}
+
+	s.SetAuthToken(resp.Token)
+	s.SetCurrentUser(resp.UserID)
+	s.SetUsername(resp.Username)
+	c.SetToken(resp.Token)
+
+	display.Println(display.Green, "Logged in successfully")
+	fmt.Printf("User ID: %s\n", resp.UserID)
+	fmt.Printf("Username: %s\n", resp.Username)
+
+	return nil
+}
+
+func logoutHandler(s *session.Session, args []string) error {
+	s.SetAuthToken("")
+	s.SetCurrentUser("")
+	s.SetUsername("")
+	c := s.GetClient().(*api.Client)
+	c.SetToken("")
+
+	display.Println(display.Green, "Logged out")
+	return nil
+}
+
+func whoamiHandler(s *session.Session, args []string) error {
+	if s.GetAuthToken() == "" {
+		display.Println(display.Yellow, "Not authenticated")
+		return nil
+	}
+
+	c := s.GetClient().(*api.Client)
+	user, err := c.GetCurrentUser()
+	if err != nil {
+		return err
+	}
+
+	display.Println(display.Cyan, "Current User:")
+	fmt.Printf("  User ID:  %s\n", user.UserID)
+	fmt.Printf("  Username: %s\n", user.Username)
+	if user.Email != "" {
+		fmt.Printf("  Email:    %s\n", user.Email)
+	}
+	fmt.Printf("  Created:  %s\n", user.CreatedAt.Format("2006-01-02 15:04:05"))
+	if user.LastLogin != nil {
+		fmt.Printf("  Last Login: %s\n", user.LastLogin.Format("2006-01-02 15:04:05"))
+	}
+
+	return nil
+}
+
+func setUserHandler(s *session.Session, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: user <userId>")
+	}
+
+	userID := args[0]
+	s.SetCurrentUser(userID)
+	display.Println(display.Cyan, "User ID set to: %s", userID)
+	fmt.Println("Note: This doesn't authenticate, just sets the ID for display")
+
+	return nil
+}

internal/client/command/debug.go

@@ -0,0 +1,109 @@
+// FILE: lixenwraith/chess/internal/client/command/debug.go
+package command
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	"chess/internal/client/api"
+	"chess/internal/client/display"
+	"chess/internal/client/session"
+)
+
+func (r *Registry) registerDebugCommands() {
+	r.Register(&Command{
+		Name:        "health",
+		ShortName:   ".",
+		Description: "Check server health",
+		Usage:       "health",
+		Handler:     healthHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "url",
+		ShortName:   "/",
+		Description: "Set API base URL",
+		Usage:       "url [apiUrl]",
+		Handler:     urlHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "raw",
+		ShortName:   ":",
+		Description: "Send raw API request",
+		Usage:       "raw <method> <path> [json-body]",
+		Handler:     rawRequestHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "clear",
+		ShortName:   "-",
+		Description: "Clear screen",
+		Usage:       "clear",
+		Handler:     clearHandler,
+	})
+}
+
+func healthHandler(s *session.Session, args []string) error {
+	c := s.GetClient().(*api.Client)
+	resp, err := c.Health()
+	if err != nil {
+		return err
+	}
+
+	display.Println(display.Cyan, "%sServer Health:%s")
+	fmt.Printf("  Status:  %s\n", resp.Status)
+	// Convert Unix timestamp to readable time
+	t := time.Unix(resp.Time, 0)
+	fmt.Printf("  Time:    %s\n", t.Format("2006-01-02 15:04:05"))
+	if resp.Storage != "" {
+		fmt.Printf("  Storage: %s\n", resp.Storage)
+	}
+
+	return nil
+}
+
+func urlHandler(s *session.Session, args []string) error {
+	if len(args) == 0 {
+		fmt.Printf("Current API URL: %s\n", s.GetAPIBaseURL())
+		return nil
+	}
+
+	url := args[0]
+	if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
+		url = "http://" + url
+	}
+
+	s.SetAPIBaseURL(url)
+	c := s.GetClient().(*api.Client)
+	c.SetBaseURL(url)
+
+	display.Println(display.Cyan, "API URL set to: %s", url)
+	return nil
+}
+
+func rawRequestHandler(s *session.Session, args []string) error {
+	if len(args) < 2 {
+		return fmt.Errorf("usage: raw <method> <path> [json-body]")
+	}
+
+	method := strings.ToUpper(args[0])
+	path := args[1]
+
+	body := ""
+	if len(args) > 2 {
+		body = strings.Join(args[2:], " ")
+	}
+
+	c := s.GetClient().(*api.Client)
+	return c.RawRequest(method, path, body)
+}
+
+func clearHandler(s *session.Session, args []string) error {
+	cmd := exec.Command("clear")
+	cmd.Stdout = os.Stdout
+	return cmd.Run()
+}

internal/client/command/game.go

@@ -0,0 +1,514 @@
+// FILE: lixenwraith/chess/internal/client/command/game.go
+package command
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"chess/internal/client/api"
+	"chess/internal/client/display"
+	"chess/internal/client/session"
+)
+
+func (r *Registry) registerGameCommands() {
+	r.Register(&Command{
+		Name:        "new",
+		ShortName:   "n",
+		Description: "Create a new game",
+		Usage:       "new",
+		Handler:     newGameHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "join",
+		ShortName:   "j",
+		Description: "Join/set current game ID",
+		Usage:       "join <gameId>",
+		Handler:     joinGameHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "move",
+		ShortName:   "m",
+		Description: "Make a move",
+		Usage:       "move <uci-move>",
+		Handler:     moveHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "computer",
+		ShortName:   "c",
+		Description: "Trigger computer move",
+		Usage:       "computer",
+		Handler:     computerMoveHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "undo",
+		ShortName:   "u",
+		Description: "Undo moves",
+		Usage:       "undo [count]",
+		Handler:     undoHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "show",
+		ShortName:   "h",
+		Description: "Show board and game state",
+		Usage:       "show",
+		Handler:     showBoardHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "state",
+		ShortName:   "s",
+		Description: "Show raw game JSON",
+		Usage:       "state",
+		Handler:     gameStateHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "delete",
+		ShortName:   "d",
+		Description: "Delete a game",
+		Usage:       "delete [gameId]",
+		Handler:     deleteGameHandler,
+	})
+
+	r.Register(&Command{
+		Name:        "poll",
+		ShortName:   "p",
+		Description: "Long-poll for game updates",
+		Usage:       "poll",
+		Handler:     pollHandler,
+	})
+}
+
+func newGameHandler(s *session.Session, args []string) error {
+	scanner := bufio.NewScanner(os.Stdin)
+	c := s.Client
+
+	display.Println(display.Cyan, "\nCreating new game...")
+
+	// White player
+	display.Print(display.Yellow, "White player type (h/c) [h]: ")
+	scanner.Scan()
+	whiteType := strings.ToLower(strings.TrimSpace(scanner.Text()))
+	if whiteType == "" {
+		whiteType = "h"
+	}
+
+	white := api.PlayerConfig{Type: 1}
+	if whiteType == "c" {
+		white.Type = 2
+
+		display.Print(display.Yellow, "Computer level (0-20) [10]: ")
+		scanner.Scan()
+		levelStr := strings.TrimSpace(scanner.Text())
+		if levelStr == "" {
+			white.Level = 10
+		} else {
+			level, _ := strconv.Atoi(levelStr)
+			white.Level = level
+		}
+
+		display.Print(display.Yellow, "Search time (100-10000ms) [1000]: ")
+		scanner.Scan()
+		timeStr := strings.TrimSpace(scanner.Text())
+		if timeStr == "" {
+			white.SearchTime = 1000
+		} else {
+			searchTime, _ := strconv.Atoi(timeStr)
+			white.SearchTime = searchTime
+		}
+	}
+
+	// Black player (same pattern)
+	display.Print(display.Yellow, "Black player type (h/c) [h]: ")
+	scanner.Scan()
+	blackType := strings.ToLower(strings.TrimSpace(scanner.Text()))
+	if blackType == "" {
+		blackType = "h"
+	}
+
+	black := api.PlayerConfig{Type: 1}
+	if blackType == "c" {
+		black.Type = 2
+
+		display.Print(display.Yellow, "Computer level (0-20) [10]: ")
+		scanner.Scan()
+		levelStr := strings.TrimSpace(scanner.Text())
+		if levelStr == "" {
+			black.Level = 10
+		} else {
+			level, _ := strconv.Atoi(levelStr)
+			black.Level = level
+		}
+
+		display.Print(display.Yellow, "Search time (100-10000ms) [1000]: ")
+		scanner.Scan()
+		timeStr := strings.TrimSpace(scanner.Text())
+		if timeStr == "" {
+			black.SearchTime = 1000
+		} else {
+			searchTime, _ := strconv.Atoi(timeStr)
+			black.SearchTime = searchTime
+		}
+	}
+
+	// Starting position
+	display.Print(display.Yellow, "Starting position (FEN) [default]: ")
+	scanner.Scan()
+	fen := strings.TrimSpace(scanner.Text())
+
+	req := &api.CreateGameRequest{
+		White: white,
+		Black: black,
+		FEN:   fen,
+	}
+
+	resp, err := c.CreateGame(req)
+	if err != nil {
+		return err
+	}
+
+	s.CurrentGame = resp.GameID
+	s.LastMoveCount = len(resp.Moves)
+	s.CurrentGameState = resp
+
+	// Determine player color if authenticated
+	if s.CurrentUser != "" {
+		if resp.Players.White.ID == s.CurrentUser {
+			s.PlayerColor = "w"
+		} else if resp.Players.Black.ID == s.CurrentUser {
+			s.PlayerColor = "b"
+		}
+	}
+
+	display.Println(display.Green, "Game created: %s", resp.GameID)
+	display.Println(display.Cyan, "Current game set to: %s", resp.GameID)
+
+	// If white is computer, inform user to trigger move
+	if white.Type == 2 {
+		display.Println(display.Magenta, "\nWhite is computer. Use 'computer' or 'c' to trigger first move.")
+	}
+
+	return nil
+}
+
+func joinGameHandler(s *session.Session, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: join <gameId>")
+	}
+
+	gameID := args[0]
+	c := s.GetClient().(*api.Client)
+
+	// Verify game exists
+	resp, err := c.GetGame(gameID)
+	if err != nil {
+		return err
+	}
+
+	s.SetCurrentGame(gameID)
+	s.SetLastMoveCount(len(resp.Moves))
+	s.SetGameState(resp)
+
+	// Determine player color if authenticated
+	if s.GetCurrentUser() != "" {
+		if resp.Players.White.ID == s.GetCurrentUser() {
+			s.SetPlayerColor("w")
+		} else if resp.Players.Black.ID == s.GetCurrentUser() {
+			s.SetPlayerColor("b")
+		} else {
+			s.SetPlayerColor("")
+		}
+	}
+
+	fmt.Printf("%sJoined game: %s%s\n", display.Green, gameID, display.Reset)
+	fmt.Printf("Turn: %s | State: %s | Moves: %d\n", resp.Turn, resp.State, len(resp.Moves))
+
+	return nil
+}
+
+func moveHandler(s *session.Session, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: move <uci-move>")
+	}
+
+	gameID := s.CurrentGame
+	if gameID == "" {
+		return fmt.Errorf("no current game, use 'new' or 'join <gameId>'")
+	}
+
+	move := args[0]
+	c := s.Client
+
+	resp, err := c.MakeMove(gameID, move)
+	if err != nil {
+		return err
+	}
+
+	s.LastMoveCount = len(resp.Moves)
+	s.CurrentGameState = resp
+	display.Println(display.Green, "Move accepted")
+
+	// Check if game ended
+	switch resp.State {
+	case "checkmate":
+		winner := "Black"
+		if resp.Turn == "b" { // Turn switches after move, so if black's turn after checkmate, white won
+			winner = "White"
+		}
+		display.Println(display.Green, "\nCHECKMATE! %s wins!", winner)
+	case "stalemate":
+		display.Println(display.Yellow, "\nSTALEMATE! Game drawn.")
+	case "draw":
+		display.Println(display.Yellow, "\nDRAW! Game drawn.")
+	case "ongoing":
+		// Check if computer needs to play
+		currentTurn := resp.Turn
+		var computerPlayer *api.PlayerInfo
+		if currentTurn == "w" && resp.Players.White.Type == 2 {
+			computerPlayer = &resp.Players.White
+		} else if currentTurn == "b" && resp.Players.Black.Type == 2 {
+			computerPlayer = &resp.Players.Black
+		}
+
+		if computerPlayer != nil {
+			display.Println(display.Magenta, "\nComputer's turn. Use 'computer' or 'c' to trigger move.")
+		}
+	}
+
+	return nil
+}
+
+func computerMoveHandler(s *session.Session, args []string) error {
+	gameID := s.CurrentGame
+	if gameID == "" {
+		return fmt.Errorf("no current game, use 'new' or 'join <gameId>'")
+	}
+
+	c := s.Client
+
+	resp, err := c.MakeMove(gameID, "cccc")
+	if err != nil {
+		return err
+	}
+
+	if resp.State == "pending" {
+		display.Println(display.Magenta, "Computer is thinking...")
+
+		// Poll for completion
+		for i := 0; i < 50; i++ {
+			time.Sleep(200 * time.Millisecond)
+			resp2, err := c.GetGame(gameID)
+			if err == nil && resp2.State != "pending" {
+				s.LastMoveCount = len(resp2.Moves)
+				s.CurrentGameState = resp2
+				if resp2.LastMove != nil {
+					display.Print(display.Magenta, "Computer played: %s", resp2.LastMove.Move)
+					if resp2.LastMove.Depth > 0 {
+						fmt.Printf(" (depth %d, score %d)", resp2.LastMove.Depth, resp2.LastMove.Score)
+					}
+					fmt.Println()
+				}
+
+				// Check if game ended after computer move
+				switch resp2.State {
+				case "checkmate":
+					winner := "Black"
+					if resp2.Turn == "b" {
+						winner = "White"
+					}
+					display.Println(display.Green, "\nCHECKMATE! %s wins!", winner)
+				case "stalemate":
+					display.Println(display.Yellow, "\nSTALEMATE! Game drawn.")
+				case "draw":
+					display.Println(display.Yellow, "\nDRAW! Game drawn.")
+				}
+
+				return nil
+			}
+		}
+		return fmt.Errorf("timeout waiting for computer move")
+	}
+
+	s.LastMoveCount = len(resp.Moves)
+	s.CurrentGameState = resp
+	display.Println(display.Green, "Move triggered")
+	return nil
+}
+
+func undoHandler(s *session.Session, args []string) error {
+	gameID := s.GetCurrentGame()
+	if gameID == "" {
+		return fmt.Errorf("no current game, use 'new' or 'join <gameId>'")
+	}
+
+	count := 1
+	if len(args) > 0 {
+		var err error
+		count, err = strconv.Atoi(args[0])
+		if err != nil {
+			return fmt.Errorf("invalid count: %s", args[0])
+		}
+	}
+
+	c := s.GetClient().(*api.Client)
+	resp, err := c.UndoMoves(gameID, count)
+	if err != nil {
+		return err
+	}
+
+	s.SetLastMoveCount(len(resp.Moves))
+	s.SetGameState(resp)
+	display.Println(display.Green, "Undid %d move(s)", count)
+	return nil
+}
+
+func showBoardHandler(s *session.Session, args []string) error {
+	gameID := s.GetCurrentGame()
+	if gameID == "" {
+		return fmt.Errorf("no current game, use 'new' or 'join <gameId>'")
+	}
+
+	c := s.GetClient().(*api.Client)
+
+	// Get full game state
+	game, err := c.GetGame(gameID)
+	if err != nil {
+		return err
+	}
+
+	// Get ASCII board
+	board, err := c.GetBoard(gameID)
+	if err != nil {
+		return err
+	}
+
+	s.SetLastMoveCount(len(game.Moves))
+	s.SetGameState(game)
+
+	// Display board with colors
+	fmt.Println()
+	display.RenderBoard(board.Board)
+
+	// Display game info
+	fmt.Printf("\nFEN: %s\n", game.FEN)
+	fmt.Printf("Turn: %s | State: %s | Moves: %d\n",
+		display.ColorForTurn(game.Turn), game.State, len(game.Moves))
+
+	// Display move history
+	if len(game.Moves) > 0 {
+		fmt.Printf("\nHistory: ")
+		for i, move := range game.Moves {
+			if i > 0 {
+				fmt.Print(" ")
+			}
+			if i%2 == 0 {
+				fmt.Printf("%d.%s", (i/2)+1, move)
+			} else {
+				fmt.Printf(" %s", move)
+			}
+		}
+		fmt.Println()
+	}
+
+	// Display last move info
+	if game.LastMove != nil {
+		color := "White"
+		if game.LastMove.PlayerColor == "b" {
+			color = "Black"
+		}
+		fmt.Printf("Last move: %s by %s", game.LastMove.Move, color)
+		if game.LastMove.Depth > 0 {
+			fmt.Printf(" (depth %d, score %d)", game.LastMove.Depth, game.LastMove.Score)
+		}
+		fmt.Println()
+	}
+
+	return nil
+}
+
+func gameStateHandler(s *session.Session, args []string) error {
+	gameID := s.GetCurrentGame()
+	if gameID == "" {
+		return fmt.Errorf("no current game, use 'new' or 'join <gameId>'")
+	}
+
+	c := s.GetClient().(*api.Client)
+	resp, err := c.GetGame(gameID)
+	if err != nil {
+		return err
+	}
+
+	s.SetLastMoveCount(len(resp.Moves))
+
+	// Pretty print JSON
+	display.Println(display.Cyan, "Game State:")
+	display.PrettyPrintJSON(resp)
+
+	return nil
+}
+
+func deleteGameHandler(s *session.Session, args []string) error {
+	gameID := s.GetCurrentGame()
+	if len(args) > 0 {
+		gameID = args[0]
+	}
+
+	if gameID == "" {
+		return fmt.Errorf("specify game ID or set current game")
+	}
+
+	c := s.GetClient().(*api.Client)
+	err := c.DeleteGame(gameID)
+	if err != nil {
+		return err
+	}
+
+	if gameID == s.GetCurrentGame() {
+		s.SetCurrentGame("")
+		s.SetLastMoveCount(0)
+	}
+
+	fmt.Printf("%sGame deleted: %s%s\n", display.Green, gameID, display.Reset)
+	return nil
+}
+
+func pollHandler(s *session.Session, args []string) error {
+	gameID := s.GetCurrentGame()
+	if gameID == "" {
+		return fmt.Errorf("no current game, use 'new' or 'join <gameId>'")
+	}
+
+	c := s.GetClient().(*api.Client)
+	moveCount := s.GetLastMoveCount()
+
+	display.Println(display.Cyan, "Long-polling for updates (move count: %d)...", moveCount)
+	display.Println(display.Cyan, "This may take up to 25 seconds")
+
+	resp, err := c.GetGameWithPoll(gameID, moveCount)
+	if err != nil {
+		return err
+	}
+
+	s.SetLastMoveCount(len(resp.Moves))
+	s.SetGameState(resp)
+
+	if len(resp.Moves) > moveCount {
+		display.Println(display.Green, "Game updated! New moves detected")
+		if resp.LastMove != nil {
+			fmt.Printf("Last move: %s\n", resp.LastMove.Move)
+		}
+	} else {
+		display.Println(display.Yellow, "No updates (timeout)")
+	}
+
+	return nil
+}

internal/client/command/pass_unix.go

@@ -0,0 +1,20 @@
+// FILE: internal/client/command/auth_unix.go
+//go:build !js && !wasm
+
+package command
+
+import (
+	"fmt"
+
+	"golang.org/x/term"
+)
+
+func readPassword(prompt string) (string, error) {
+	fmt.Print(prompt)
+	bytePassword, err := term.ReadPassword(0) // 0 is stdin
+	fmt.Println()
+	if err != nil {
+		return "", err
+	}
+	return string(bytePassword), nil
+}

internal/client/command/pass_wasm.go

@@ -0,0 +1,29 @@
+// FILE: lixenwraith/chess/internal/client/command/auth_wasm.go
+//go:build js && wasm
+
+package command
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+
+	"chess/internal/client/display"
+)
+
+func readPassword(prompt string) (string, error) {
+	display.Println(display.Red, "(warning: password visible in browser)")
+	display.Print(display.Yellow, prompt)
+
+	// In WASM/browser, password masking must be handled by JavaScript/xterm.js
+	// This is fallback with visible input
+	scanner := bufio.NewScanner(os.Stdin)
+	if scanner.Scan() {
+		return strings.TrimSpace(scanner.Text()), nil
+	}
+	if err := scanner.Err(); err != nil {
+		return "", err
+	}
+	return "", fmt.Errorf("no input received")
+}

internal/client/command/registry.go

@@ -0,0 +1,176 @@
+// FILE: lixenwraith/chess/internal/client/command/registry.go
+package command
+
+import (
+	"fmt"
+	"strings"
+
+	"chess/internal/client/api"
+	"chess/internal/client/display"
+	"chess/internal/client/session"
+)
+
+// Command defines a client command with its handler
+type Command struct {
+	Name        string
+	ShortName   string
+	Description string
+	Usage       string
+	Handler     func(*session.Session, []string) error
+}
+
+type Registry struct {
+	session  *session.Session
+	commands map[string]*Command
+}
+
+// Registry manages command registration and execution
+func NewRegistry(s *session.Session) *Registry {
+	r := &Registry{
+		session:  s,
+		commands: make(map[string]*Command),
+	}
+
+	// Register all commands
+	r.registerGameCommands()
+	r.registerAuthCommands()
+	r.registerDebugCommands()
+
+	// Help command
+	r.Register(&Command{
+		Name:        "help",
+		ShortName:   "?",
+		Description: "Show available commands",
+		Usage:       "help [command]",
+		Handler:     r.helpHandler,
+	})
+
+	// Exit command (handled in main loop, but registered for help display)
+	r.Register(&Command{
+		Name:        "exit",
+		ShortName:   "x",
+		Description: "Exit the client",
+		Usage:       "exit",
+		Handler:     exitHandler,
+	})
+
+	return r
+}
+
+func (r *Registry) Register(cmd *Command) {
+	r.commands[cmd.Name] = cmd
+	if cmd.ShortName != "" {
+		r.commands[cmd.ShortName] = cmd
+	}
+}
+
+func (r *Registry) Execute(input string) {
+	parts := strings.Fields(input)
+	if len(parts) == 0 {
+		return
+	}
+
+	cmdName := parts[0]
+	args := parts[1:]
+
+	cmd, exists := r.commands[cmdName]
+	if !exists {
+		display.Println(display.Red, "Unknown command: %s", cmdName)
+		display.Println(display.Reset, "Type 'help' for available commands")
+		return
+	}
+
+	// Set verbose mode in client if session supports it
+	if cl, ok := r.session.GetClient().(*api.Client); ok {
+		cl.SetVerbose(r.session.IsVerbose())
+	}
+
+	if err := cmd.Handler(r.session, args); err != nil {
+		display.Println(display.Red, "Error: %s", err.Error())
+	}
+}
+
+func (r *Registry) helpHandler(s *session.Session, args []string) error {
+	if len(args) > 0 {
+		// Show help for specific command
+		cmd, exists := r.commands[args[0]]
+		if !exists {
+			return fmt.Errorf("unknown command: %s", args[0])
+		}
+		fmt.Println()
+		display.Print(display.Cyan, cmd.Name)
+		display.Println(display.Reset, " - %s", cmd.Description)
+		if cmd.ShortName != "" {
+			display.Println(display.Cyan, "Short form: %s", cmd.ShortName)
+		}
+		fmt.Printf("Usage: %s\n", cmd.Usage)
+		return nil
+	}
+
+	// Show all commands
+	display.Println(display.Cyan, "\nAvailable Commands:\n")
+
+	// Group commands
+	type cmdInfo struct {
+		name      string
+		shortName string
+		desc      string
+	}
+
+	gameCommands := []cmdInfo{
+		{"new", "n", ""},
+		{"join", "j", ""},
+		{"move", "m", ""},
+		{"computer", "c", ""},
+		{"undo", "u", ""},
+		{"show", "h", ""},
+		{"state", "s", ""},
+		{"delete", "d", ""},
+		{"poll", "p", ""},
+	}
+
+	authCommands := []cmdInfo{
+		{"register", "r", ""},
+		{"login", "l", ""},
+		{"logout", "o", ""},
+		{"whoami", "i", ""},
+		{"user", "e", ""},
+	}
+
+	utilCommands := []cmdInfo{
+		{"health", ".", ""},
+		{"url", "/", ""},
+		{"raw", ":", ""},
+		{"clear", "-", ""},
+		{"help", "?", ""},
+		{"exit", "x", ""},
+	}
+
+	printCommandGroup := func(title string, cmds []cmdInfo) {
+		display.Println(display.Yellow, "%s:", title)
+		for _, info := range cmds {
+			if cmd, exists := r.commands[info.name]; exists {
+				shortPart := ""
+				if info.shortName != "" {
+					shortPart = fmt.Sprintf("[%s%s%s] ", display.Cyan, info.shortName, display.Reset)
+				}
+				fmt.Printf("  %s%-10s %s\n", shortPart, cmd.Name, cmd.Description)
+			}
+		}
+		fmt.Println()
+	}
+
+	printCommandGroup("Game Commands", gameCommands)
+	printCommandGroup("Auth Commands", authCommands)
+	printCommandGroup("Utility Commands", utilCommands)
+
+	display.Println(display.Reset, "Type 'help <command>' for detailed usage")
+	display.Println(display.Reset, "Add '-v' to any command for verbose output\n")
+	return nil
+}
+
+func exitHandler(s *session.Session, args []string) error {
+	// Exit is handled in main loop, this is just for consistency
+	display.Println(display.Cyan, "Goodbye!\n")
+	return nil
+}