uci/cmd.go (1)

123-144: Improve the CmdEval implementation with better magic number handling and error handling

The implementation works correctly for Stockfish, but has a few areas for improvement:

1. Magic numbers should be named constants for better readability
2. Error handling for the ParseFloat operation could be improved
3. The implementation assumes a Stockfish-specific output format

// CmdEval is a non-standard command that requests the engine's static evaluation of the current position.
+const (
+    // evalIndexInParts is the index of the evaluation value in the space-separated output
+    evalIndexInParts = 2
+    // centipawnScale converts from decimal pawn values to centipawn integer values
+    centipawnScale = 100
+)

CmdEval = cmdNoOptions{Name: "eval", F: func(e *Engine) error {
    scanner := bufio.NewScanner(e.out)
    for scanner.Scan() {
        text := e.readLine(scanner)
        if strings.Contains(text, "error") {
            return errors.New("eval command not supported")
        }
        if strings.HasPrefix(text, "Final evaluation") {
            parts := strings.Fields(text)
-           if len(parts) >= 3 {
+           if len(parts) > evalIndexInParts {
-               evalStr := parts[2]
+               evalStr := parts[evalIndexInParts]
                eval, err := strconv.ParseFloat(evalStr, 64)
                if err == nil {
-                   e.eval = int(math.Round(eval * 100))
+                   e.eval = int(math.Round(eval * centipawnScale))
+               } else {
+                   return fmt.Errorf("failed to parse evaluation value: %w", err)
                }
                break
            }
        }
    }
    return nil
}}

🧰 Tools

🪛 golangci-lint (1.64.8)

137-137: Magic number: 100, in detected

(mnd)

---

133-133: Magic number: 3, in detected

(mnd)

uci/engine_test.go (1)

22-60: LGTM: Good test coverage for eval functionality

The test thoroughly checks both successful evaluation with Stockfish and proper error handling with lc0, which doesn't support the eval command. The test covers:

1. Setting up a specific chess position
2. Running the eval command
3. Verifying the expected outcomes for different engines

One minor suggestion: consider making the minimum expected evaluation value a named constant for better maintainability.

func Test_EngineEval(t *testing.T) {
+   const minExpectedEval = 500
    for _, name := range engines {
        fenStr := "4k3/8/8/8/8/8/8/4K2R w - - 0 1"

        t.Run("EngineEval_"+name, func(t *testing.T) {
            if !isEngineAvailable(name) {
                t.Skipf("engine %s not available", name)
            }

            pos := &chess.Position{}
            if err := pos.UnmarshalText([]byte(fenStr)); err != nil {
                t.Fatal("failed to parse FEN", err)
            }

            eng, err := uci.New(name, uci.Debug)
            if err != nil {
                t.Fatal(err)
            }
            defer eng.Close()

            cmdPos := uci.CmdPosition{Position: pos}
            err = eng.Run(uci.CmdUCI, uci.CmdIsReady, uci.CmdUCINewGame, cmdPos, uci.CmdEval)

            if name == "stockfish" {
                if err != nil {
                    t.Fatal("failed to run command", err)
                }

-               if eng.Eval() < 500 {
+               if eng.Eval() < minExpectedEval {
-                   t.Errorf("expected an eval greater than or equal to 500, got %d", eng.Eval())
+                   t.Errorf("expected an eval greater than or equal to %d, got %d", minExpectedEval, eng.Eval())
                }
            } else if name == "lc0" {
                if err == nil {
                    t.Fatal("expected an error", err)
                }
            }
        })
    }
}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
Cache: Disabled due to data retention organization setting
Knowledge Base: Disabled due to data retention organization setting