Add word guess, higher lower, custom instructions and update CI workflow (#14)

* Add copilot instructions for GitHub game development guidelines

* Add Higher or Lower and Word Guess games; update CI workflow

- Implemented a new Higher or Lower number guessing game.
- Added a Word Guess game where players guess GitHub-related terms.
- Updated the CI workflow to include linting and formatting checks.
- Removed the Whoami command and refactored the root command initialization.
- Added tests for the new games and updated existing tests for consistency.
- Updated Go module to use Go 1.24 and removed unnecessary seeding in random number generation.

* Add tests for edge cases in Word Guess game and enhance game logic validation

* Refactor test setup functions to include testing.T parameter for better error handling

* Remove unused init function from root command

* Remove unnecessary comments about seeding in Go 1.20+ from game files

* Remove unnecessary file path comments from wordguess package and test files

* Enhance mock prompter implementations across game tests with detailed comments for clarity and maintainability

* Refactor PlayGame test comments for clarity and improved understanding of test purpose

* Run go fmt

Author: chrisreddington

.github/copilot-instructions.md

@@ -0,0 +1,73 @@
+# GitHub Game - Copilot Instructions
+
+## Project Overview
+This is a GitHub CLI Extension written in Go that allows users to play various games (coin toss, rock paper scissors, tic tac toe) through the GitHub CLI. It's built using Go and the GitHub CLI extension framework, leveraging the Cobra command library for CLI functionality and Charm libraries for terminal UI rendering.
+
+## Code Standards
+
+### Required Before Commit
+- All tests must pass: `go test ./...`
+- Code must be properly formatted: `go fmt ./...`
+- Linting must pass: `golangci-lint run`
+- Ensure documentation is up-to-date for any new commands or features
+- Verify that any new game implementation follows the established patterns
+
+### Go Patterns
+- Follow standard Go idioms and best practices
+- Use GoDoc comments for all exported functions, types, and packages:
+  ```go
+  // FunctionName does something specific
+  // with these parameters and returns this result
+  func FunctionName() {}
+  ```
+- Error handling should follow Go conventions (return errors rather than using exceptions)
+- Use meaningful variable and function names that describe their purpose
+- Keep functions small and focused on a single responsibility
+- Separate interface definitions from implementations where appropriate
+
+## Development Flow
+
+- Build: `go build`
+- Test: `go test ./...`
+- Lint: `golangci-lint run`
+- Format: `go fmt ./...`
+- Run: `gh game <subcommand>` (e.g., `gh game cointoss`)
+
+## Repository Structure
+- `/cmd`: Main command implementations and CLI structure
+  - Command files for each game and core CLI functionality
+- `/internal`: Internal packages not intended for external use
+  - Game logic implementations
+  - Utility functions
+- `/pkg`: Public libraries that could potentially be used by other projects
+- `/test`: Test utilities and fixtures
+- `main.go`: Entry point for the application
+- `README.md`: Project documentation
+- `LICENSE`: MIT license file
+- `go.mod` & `go.sum`: Go module declarations and dependency tracking
+
+## Key Guidelines
+
+1. **User Experience Focus**:
+   - Games should be intuitive and easy to play
+   - Provide clear instructions and feedback to the user
+   - Handle errors gracefully with helpful messages
+
+2. **Command Structure**:
+   - New games should be added as subcommands to the main `gh game` command
+   - Maintain consistency in command structure and naming
+
+3. **Terminal UI**:
+   - Use the Charm libraries (lipgloss, etc.) for consistent UI rendering
+   - Ensure games are playable in different terminal environments
+   - Consider accessibility in UI design (e.g., color contrast)
+
+4. **Testing**:
+   - Write unit tests for game logic
+   - Include integration tests for command behavior
+   - Mock external dependencies when testing
+
+5. **Documentation**:
+   - Update README when adding new games or features
+   - Include usage examples for each game
+   - Document any complex algorithms or design decisions

.github/workflows/ci.yml

@@ -14,15 +14,31 @@ jobs:
   build:    
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
 
       - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@0aaccfd150d50ccaeb58ebd88d36e91967a5f35b
         with:
           go-version: '1.24' # You can change this to your desired Go version
 
+      - name: Install golangci-lint
+        uses: golangci/golangci-lint-action@1481404843c368bc19ca9406f87d6e0fc97bdcfd
+        with:
+          version: latest
+
       - name: Build
         run: go build -v ./...
 
+      - name: Lint
+        run: golangci-lint run
+
+      - name: Format Check
+        run: |
+          go fmt ./...
+          if [ -n "$(git diff)" ]; then
+            echo "Code is not properly formatted. Please run 'go fmt ./...'"
+            exit 1
+          fi
+
       - name: Test
         run: go test -v ./...

README.md

@@ -20,6 +20,23 @@ gh game cointoss heads  # or tails
 
 The game will continue as long as you keep guessing correctly, allowing you to build up a streak. You can quit at any time by selecting "Quit" when prompted for your next guess.
 
+### Higher or Lower
+
+Play a number guessing game where you predict if the next random number will be higher or lower than the current one. See how long you can maintain your streak of correct guesses!
+
+```sh
+gh game higherlower
+```
+
+Optional flags:
+- `--min` or `-m`: Set the minimum possible number (default: 1)
+- `--max` or `-M`: Set the maximum possible number (default: 100)
+
+Example with custom range:
+```sh
+gh game higherlower --min 1 --max 1000
+```
+
 ### Rock Paper Scissors
 
 Play Rock Paper Scissors against the computer. Best of 3, 5, 7, or 9 rounds.
@@ -43,14 +60,16 @@ gh game tictactoe
 
 The game provides an interactive interface where you can select positions on the board using numbers 1-9, corresponding to the grid positions from left to right, top to bottom.
 
-### Whoami
+### Word Guess
 
-Display information about the currently authenticated GitHub user.
+Play a word guessing game where you guess a GitHub-related term one letter at a time. Try to reveal the word before running out of guesses!
 
 ```sh
-gh game whoami
+gh game wordguess
 ```
 
+The game selects a random GitHub-related term, and you need to guess it by suggesting one letter at a time. Each correct letter is revealed in its position. Each incorrect guess reduces your remaining guesses. You win by guessing the complete word before making 6 incorrect guesses.
+
 ## Development
 
 ### Prerequisites

cmd/higherlower.go

@@ -0,0 +1,42 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/chrisreddington/gh-game/internal/higherlower"
+	userPrompt "github.com/cli/go-gh/v2/pkg/prompter"
+	"github.com/spf13/cobra"
+)
+
+var (
+	minNumber int
+	maxNumber int
+)
+
+var higherLowerCmd = &cobra.Command{
+	Use:   "higherlower",
+	Short: "Play Higher or Lower",
+	Long: `Play a Higher or Lower number guessing game.
+	
+A number will be shown and you need to guess whether the
+next number will be higher or lower than the current number.
+
+The game continues until you make an incorrect guess. How long of a streak 
+can you get?
+
+Example usage:
+  gh game higherlower
+  gh game higherlower --min 1 --max 1000`,
+	Args: cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
+		input := userPrompt.New(os.Stdin, os.Stdout, os.Stderr)
+		higherlower.PlayGame(input, minNumber, maxNumber)
+	},
+}
+
+func init() {
+	higherLowerCmd.Flags().IntVarP(&minNumber, "min", "m", 1, "Minimum possible number")
+	higherLowerCmd.Flags().IntVarP(&maxNumber, "max", "M", 100, "Maximum possible number")
+
+	rootCmd.AddCommand(higherLowerCmd)
+}

cmd/root.go

@@ -13,10 +13,3 @@ var rootCmd = &cobra.Command{
 func Execute() error {
 	return rootCmd.Execute()
 }
-
-func init() {
-	rootCmd.AddCommand(whoamiCmd)
-	rootCmd.AddCommand(cointossCmd)
-	rootCmd.AddCommand(tictactoeCmd)
-	rootCmd.AddCommand(rockPaperScissorsCmd)
-}

cmd/tictactoe.go

@@ -98,3 +98,7 @@ Choose between two game modes:
 		}
 	},
 }
+
+func init() {
+	rootCmd.AddCommand(tictactoeCmd)
+}

cmd/whoami.go

@@ -0,0 +1,31 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/chrisreddington/gh-game/internal/wordguess"
+	userPrompt "github.com/cli/go-gh/v2/pkg/prompter"
+	"github.com/spf13/cobra"
+)
+
+var wordguessCmd = &cobra.Command{
+	Use:   "wordguess",
+	Short: "Play Word Guess",
+	Long: `Start a game of Word Guess where you guess a GitHub-related term one letter at a time.
+	
+The rules are simple:
+1. A random word will be selected
+2. Guess one letter at a time
+3. If the letter is in the word, it will be revealed
+4. If not, you lose one of your available guesses
+5. You win by guessing the word before running out of guesses
+6. You lose if you make 6 incorrect guesses`,
+	Run: func(cmd *cobra.Command, args []string) {
+		input := userPrompt.New(os.Stdin, os.Stdout, os.Stderr)
+		wordguess.PlayGame(input)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(wordguessCmd)
+}

cmd/wordguess.go

@@ -1,6 +1,7 @@
 module github.com/chrisreddington/gh-game
 
 go 1.23.3
+
 toolchain go1.24.1
 
 require (

go.mod

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math/rand"
 	"strings"
-	"time"
 )
 
 // Game represents the state of a coin toss game
@@ -27,7 +26,6 @@ func NewGame() *Game {
 
 // TossCoin is a variable so it can be replaced in tests
 var TossCoin = func() string {
-	rand.Seed(time.Now().UnixNano())
 	if rand.Float32() < 0.5 {
 		return "heads"
 	}
@@ -85,7 +83,7 @@ func PlayGame(p prompter, initialGuess string) {
 	for keepPlaying {
 		game.Play(guess)
 		fmt.Println(game.GetResult())
-		
+
 		if game.PlayerGuess == game.Result {
 			streak++
 			fmt.Printf("Streak: %d\n", streak)