fix: remove code duplication and make depth configurable in engine analysis

- Make useEngineAnalysis accept configurable target depth instead of hardcoded 18
- Remove duplicate useGameAnalysis hook to eliminate code duplication
- Create simple batch analysis that reuses existing useEngineAnalysis infrastructure
- Fix depth configuration bug where analysis always used depth 18
- Ensure both single-position and batch analysis use same underlying logic

Co-authored-by: kevinjosethomas <46242684+kevinjosethomas@users.noreply.github.com>

Author: Copilot

src/components/Analysis/AnalysisProgressOverlay.tsx

@@ -1,6 +1,6 @@
 import React from 'react'
 import { motion } from 'framer-motion'
-import { GameAnalysisProgress } from 'src/hooks/useAnalysisController/useGameAnalysis'
+import { GameAnalysisProgress } from 'src/hooks/useAnalysisController/useAnalysisController'
 
 interface Props {
   progress: GameAnalysisProgress

src/hooks/useAnalysisController/index.ts

@@ -3,4 +3,3 @@ export * from './useEngineAnalysis'
 export * from './useAnalysisController'
 export * from './useMoveRecommendations'
 export * from './useBoardDescription'
-export * from './useGameAnalysis'

src/hooks/useAnalysisController/useAnalysisController.ts

@@ -1,18 +1,38 @@
 import { Chess } from 'chess.ts'
-import { Key, useContext, useEffect, useMemo, useState } from 'react'
+import {
+  Key,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+  useCallback,
+  useRef,
+} from 'react'
 
-import { AnalyzedGame } from 'src/types'
+import { AnalyzedGame, GameNode } from 'src/types'
 import type { DrawShape } from 'chessground/draw'
 import { MAIA_MODELS } from 'src/constants/common'
 import { useTreeController, useLocalStorage } from '..'
 import { useEngineAnalysis } from './useEngineAnalysis'
-import { useGameAnalysis } from './useGameAnalysis'
 import { useBoardDescription } from './useBoardDescription'
 import { useMoveRecommendations } from './useMoveRecommendations'
 import { MaiaEngineContext } from 'src/contexts/MaiaEngineContext'
 import { generateColorSanMapping, calculateBlunderMeter } from './utils'
 import { StockfishEngineContext } from 'src/contexts/StockfishEngineContext'
 
+export interface GameAnalysisProgress {
+  currentMoveIndex: number
+  totalMoves: number
+  currentMove: string
+  isAnalyzing: boolean
+  isComplete: boolean
+  isCancelled: boolean
+}
+
+export interface GameAnalysisConfig {
+  targetDepth: number
+}
+
 export const useAnalysisController = (
   game: AnalyzedGame,
   initialOrientation?: 'white' | 'black',
@@ -30,6 +50,151 @@ export const useAnalysisController = (
   const [analysisState, setAnalysisState] = useState(0)
   const inProgressAnalyses = useMemo(() => new Set<string>(), [])
 
+  // Game analysis state
+  const [gameAnalysisConfig, setGameAnalysisConfig] =
+    useState<GameAnalysisConfig>({
+      targetDepth: 18,
+    })
+
+  const [gameAnalysisProgress, setGameAnalysisProgress] =
+    useState<GameAnalysisProgress>({
+      currentMoveIndex: 0,
+      totalMoves: 0,
+      currentMove: '',
+      isAnalyzing: false,
+      isComplete: false,
+      isCancelled: false,
+    })
+
+  const gameAnalysisController = useRef<{
+    cancelled: boolean
+    currentNode: GameNode | null
+  }>({
+    cancelled: false,
+    currentNode: null,
+  })
+
+  // Simple batch analysis functions that reuse existing analysis infrastructure
+  const startGameAnalysis = useCallback(
+    async (targetDepth: number) => {
+      // If already analyzing, cancel the current analysis first
+      if (gameAnalysisProgress.isAnalyzing) {
+        gameAnalysisController.current.cancelled = true
+        stockfish.stopEvaluation()
+      }
+
+      // Reset state
+      gameAnalysisController.current.cancelled = false
+      gameAnalysisController.current.currentNode = null
+
+      const mainLine = game.tree.getMainLine()
+
+      setGameAnalysisConfig({ targetDepth })
+      setGameAnalysisProgress({
+        currentMoveIndex: 0,
+        totalMoves: mainLine.length,
+        currentMove: '',
+        isAnalyzing: true,
+        isComplete: false,
+        isCancelled: false,
+      })
+
+      // Wait for engines to be ready
+      let retries = 0
+      const maxRetries = 50 // 5 seconds
+
+      while (
+        retries < maxRetries &&
+        (!stockfish.isReady() || maia.status !== 'ready') &&
+        !gameAnalysisController.current.cancelled
+      ) {
+        await new Promise((resolve) => setTimeout(resolve, 100))
+        retries++
+      }
+
+      if (gameAnalysisController.current.cancelled) {
+        setGameAnalysisProgress((prev) => ({
+          ...prev,
+          isAnalyzing: false,
+          isCancelled: true,
+        }))
+        return
+      }
+
+      // Analyze each position in the main line
+      for (let i = 0; i < mainLine.length; i++) {
+        if (gameAnalysisController.current.cancelled) break
+
+        const node = mainLine[i]
+        gameAnalysisController.current.currentNode = node
+
+        // Update the UI to show the current node being analyzed (live update)
+        controller.setCurrentNode(node)
+
+        const moveDisplay = node.san || node.move || `Position ${i + 1}`
+
+        setGameAnalysisProgress((prev) => ({
+          ...prev,
+          currentMoveIndex: i + 1,
+          currentMove: moveDisplay,
+        }))
+
+        // Wait for analysis to reach target depth (the useEngineAnalysis will handle this)
+        let analysisRetries = 0
+        const maxAnalysisRetries = 600 // 60 seconds max per position
+
+        while (
+          analysisRetries < maxAnalysisRetries &&
+          !gameAnalysisController.current.cancelled &&
+          (!node.analysis.stockfish ||
+            node.analysis.stockfish.depth < targetDepth)
+        ) {
+          await new Promise((resolve) => setTimeout(resolve, 100))
+          analysisRetries++
+        }
+      }
+
+      // Analysis complete
+      setGameAnalysisProgress((prev) => ({
+        ...prev,
+        isAnalyzing: false,
+        isComplete: !gameAnalysisController.current.cancelled,
+        isCancelled: gameAnalysisController.current.cancelled,
+      }))
+
+      gameAnalysisController.current.currentNode = null
+    },
+    [
+      game.tree,
+      gameAnalysisProgress.isAnalyzing,
+      stockfish,
+      maia.status,
+      controller.setCurrentNode,
+    ],
+  )
+
+  const cancelGameAnalysis = useCallback(() => {
+    gameAnalysisController.current.cancelled = true
+    stockfish.stopEvaluation()
+
+    setGameAnalysisProgress((prev) => ({
+      ...prev,
+      isAnalyzing: false,
+      isCancelled: true,
+    }))
+  }, [stockfish])
+
+  const resetGameAnalysisProgress = useCallback(() => {
+    setGameAnalysisProgress({
+      currentMoveIndex: 0,
+      totalMoves: 0,
+      currentMove: '',
+      isAnalyzing: false,
+      isComplete: false,
+      isCancelled: false,
+    })
+  }, [])
+
   const [currentMove, setCurrentMove] = useState<[string, string] | null>()
   const [currentMaiaModel, setCurrentMaiaModel] = useLocalStorage(
     'currentMaiaModel',
@@ -47,13 +212,7 @@ export const useAnalysisController = (
     inProgressAnalyses,
     currentMaiaModel,
     setAnalysisState,
-  )
-
-  const gameAnalysis = useGameAnalysis(
-    game.tree,
-    currentMaiaModel,
-    setAnalysisState,
-    controller.setCurrentNode,
+    gameAnalysisProgress.isAnalyzing ? gameAnalysisConfig.targetDepth : 18,
   )
 
   const availableMoves = useMemo(() => {
@@ -187,6 +346,14 @@ export const useAnalysisController = (
     arrows,
     stockfish: stockfish,
     maia: maia,
-    gameAnalysis,
+    gameAnalysis: {
+      progress: gameAnalysisProgress,
+      config: gameAnalysisConfig,
+      setConfig: setGameAnalysisConfig,
+      startAnalysis: startGameAnalysis,
+      cancelAnalysis: cancelGameAnalysis,
+      resetProgress: resetGameAnalysisProgress,
+      isEnginesReady: stockfish.isReady() && maia.status === 'ready',
+    },
   }
 }

src/hooks/useAnalysisController/useEngineAnalysis.ts

@@ -8,9 +8,9 @@ import { MaiaEngineContext, StockfishEngineContext } from 'src/contexts'
 export const useEngineAnalysis = (
   currentNode: GameNode | null,
   inProgressAnalyses: Set<string>,
-
   currentMaiaModel: string,
   setAnalysisState: React.Dispatch<React.SetStateAction<number>>,
+  targetDepth = 18,
 ) => {
   const maia = useContext(MaiaEngineContext)
   const stockfish = useContext(StockfishEngineContext)
@@ -132,7 +132,7 @@ export const useEngineAnalysis = (
     if (!currentNode) return
     if (
       currentNode.analysis.stockfish &&
-      currentNode.analysis.stockfish?.depth >= 18
+      currentNode.analysis.stockfish?.depth >= targetDepth
     )
       return
 
@@ -160,6 +160,7 @@ export const useEngineAnalysis = (
       const evaluationStream = stockfish.streamEvaluations(
         chess.fen(),
         chess.moves().length,
+        targetDepth,
       )
 
       if (evaluationStream && !cancelled) {
@@ -194,5 +195,5 @@ export const useEngineAnalysis = (
       cancelled = true
       clearTimeout(timeoutId)
     }
-  }, [currentNode, stockfish, currentMaiaModel, setAnalysisState])
+  }, [currentNode, stockfish, currentMaiaModel, setAnalysisState, targetDepth])
 }