v0.1.0 chess game in go, using external stockfish engine

internal/engine/engine.go

@@ -0,0 +1,231 @@
+// FILE: internal/engine/engine.go
+package engine
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"os/exec"
+	"strings"
+	"sync"
+	"time"
+)
+
+const enginePath = "stockfish"
+
+type UCI struct {
+	cmd    *exec.Cmd
+	stdin  io.WriteCloser
+	stdout *bufio.Scanner
+	mu     sync.Mutex
+}
+
+type SearchResult struct {
+	BestMove string
+	Score    int
+	Depth    int
+}
+
+func New() (*UCI, error) {
+	cmd := exec.Command(enginePath)
+
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, err
+	}
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, err
+	}
+
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("failed to start engine: %v", err)
+	}
+
+	uci := &UCI{
+		cmd:    cmd,
+		stdin:  stdin,
+		stdout: bufio.NewScanner(stdout),
+	}
+
+	if err := uci.initialize(); err != nil {
+		uci.Close()
+		return nil, err
+	}
+
+	return uci, nil
+}
+
+// Get FEN from Stockfish's debug ('d') command
+func (u *UCI) GetFEN() (string, error) {
+	u.sendCommand("d")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	done := make(chan string, 1)
+	go func() {
+		for u.stdout.Scan() {
+			line := u.stdout.Text()
+			if strings.HasPrefix(line, "Fen: ") {
+				done <- strings.TrimPrefix(line, "Fen: ")
+				return
+			}
+		}
+		done <- ""
+	}()
+
+	select {
+	case fen := <-done:
+		if fen == "" {
+			return "", fmt.Errorf("failed to get FEN from engine")
+		}
+		return fen, nil
+	case <-ctx.Done():
+		return "", fmt.Errorf("timeout getting FEN")
+	}
+}
+
+func (u *UCI) initialize() error {
+	u.sendCommand("uci")
+
+	// Wait for uciok with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	done := make(chan bool)
+	go func() {
+		for u.stdout.Scan() {
+			if u.stdout.Text() == "uciok" {
+				done <- true
+				return
+			}
+		}
+		done <- false
+	}()
+
+	select {
+	case success := <-done:
+		if !success {
+			return fmt.Errorf("engine closed unexpectedly")
+		}
+	case <-ctx.Done():
+		return fmt.Errorf("timeout waiting for uciok")
+	}
+
+	u.sendCommand("isready")
+	return u.waitReady()
+}
+
+func (u *UCI) waitReady() error {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	done := make(chan error)
+	go func() {
+		for u.stdout.Scan() {
+			if u.stdout.Text() == "readyok" {
+				done <- nil
+				return
+			}
+		}
+		done <- fmt.Errorf("engine closed unexpectedly")
+	}()
+
+	select {
+	case err := <-done:
+		return err
+	case <-ctx.Done():
+		return fmt.Errorf("timeout waiting for readyok")
+	}
+}
+
+func (u *UCI) sendCommand(cmd string) {
+	u.mu.Lock()
+	defer u.mu.Unlock()
+	fmt.Fprintln(u.stdin, cmd)
+}
+
+func (u *UCI) NewGame() {
+	u.sendCommand("ucinewgame")
+	u.sendCommand("isready")
+	u.waitReady()
+}
+
+func (u *UCI) SetPosition(fen string, moves []string) {
+	cmd := fmt.Sprintf("position fen %s", fen)
+	if len(moves) > 0 {
+		cmd += " moves " + strings.Join(moves, " ")
+	}
+	u.sendCommand(cmd)
+}
+
+func (u *UCI) Search(timeMs int) (*SearchResult, error) {
+	u.sendCommand(fmt.Sprintf("go movetime %d", timeMs))
+
+	result := &SearchResult{}
+
+	// Add timeout protection (2x the search time + buffer)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeMs*2+1000)*time.Millisecond)
+	defer cancel()
+
+	done := make(chan error)
+	go func() {
+		for u.stdout.Scan() {
+			line := u.stdout.Text()
+
+			if strings.HasPrefix(line, "info ") {
+				fields := strings.Fields(line)
+				for i := 0; i < len(fields)-1; i++ {
+					switch fields[i] {
+					case "depth":
+						fmt.Sscanf(fields[i+1], "%d", &result.Depth)
+					case "cp":
+						fmt.Sscanf(fields[i+1], "%d", &result.Score)
+					}
+				}
+			}
+
+			if strings.HasPrefix(line, "bestmove ") {
+				parts := strings.Fields(line)
+				if len(parts) >= 2 {
+					result.BestMove = parts[1]
+				}
+				done <- nil
+				return
+			}
+		}
+		done <- fmt.Errorf("engine closed unexpectedly")
+	}()
+
+	select {
+	case err := <-done:
+		if err != nil {
+			return nil, err
+		}
+		return result, nil
+	case <-ctx.Done():
+		return nil, fmt.Errorf("timeout waiting for bestmove")
+	}
+}
+
+func (u *UCI) Close() error {
+	u.sendCommand("quit")
+	time.Sleep(100 * time.Millisecond)
+
+	// Try graceful shutdown first
+	done := make(chan error, 1)
+	go func() {
+		done <- u.cmd.Wait()
+	}()
+
+	select {
+	case <-done:
+		return nil
+	case <-time.After(1 * time.Second):
+		// Force kill if doesn't exit gracefully
+		return u.cmd.Process.Kill()
+	}
+}