feat: add Stockfish readiness check and retry logic in engine analysis; refactor useAnalysisController and useEngineAnalysis hooks

Author: kevinjosethomas

src/hooks/useAnalysisController/useAnalysisController.ts

@@ -31,7 +31,7 @@ export const useAnalysisController = (
     downloadModel: downloadMaia,
   } = useMaiaEngine()
 
-  const { streamEvaluations, stopEvaluation } = useStockfishEngine()
+  const { streamEvaluations, stopEvaluation, isReady: isStockfishReady } = useStockfishEngine()
   const [currentMove, setCurrentMove] = useState<[string, string] | null>()
   const [currentMaiaModel, setCurrentMaiaModel] = useLocalStorage(
     'currentMaiaModel',
@@ -51,6 +51,7 @@ export const useAnalysisController = (
     maia,
     streamEvaluations,
     stopEvaluation,
+    isStockfishReady,
     currentMaiaModel,
     setAnalysisState,
   )

src/hooks/useAnalysisController/useEngineAnalysis.ts

@@ -31,6 +31,7 @@ export const useEngineAnalysis = (
   maia: { batchEvaluate: EngineHooks['maia']['batchEvaluate'] },
   streamEvaluations: EngineHooks['streamEvaluations'],
   stopEvaluation: EngineHooks['stopEvaluation'],
+  isStockfishReady: () => boolean,
   currentMaiaModel: string,
   setAnalysisState: React.Dispatch<React.SetStateAction<number>>,
 ) => {
@@ -63,15 +64,28 @@ export const useEngineAnalysis = (
     const board = new Chess(currentNode.fen)
     const nodeFen = currentNode.fen
 
-    ;(async () => {
+    const attemptMaiaAnalysis = async () => {
       if (
         !currentNode ||
-        maiaStatus !== 'ready' ||
         currentNode.analysis.maia ||
         inProgressAnalyses.has(nodeFen)
       )
         return
 
+      // Add retry logic for Maia initialization
+      let retries = 0
+      const maxRetries = 30 // 3 seconds with 100ms intervals
+      
+      while (retries < maxRetries && maiaStatus !== 'ready') {
+        await new Promise(resolve => setTimeout(resolve, 100))
+        retries++
+      }
+      
+      if (maiaStatus !== 'ready') {
+        console.warn('Maia not ready after waiting, skipping analysis')
+        return
+      }
+
       inProgressAnalyses.add(nodeFen)
 
       try {
@@ -110,7 +124,9 @@ export const useEngineAnalysis = (
       } finally {
         inProgressAnalyses.delete(nodeFen)
       }
-    })()
+    }
+
+    attemptMaiaAnalysis()
   }, [
     maiaStatus,
     currentNode,
@@ -129,31 +145,51 @@ export const useEngineAnalysis = (
     )
       return
 
-    const evaluationStream = streamEvaluations(
-      board.fen(),
-      board.moves().length,
-    )
+    // Add retry logic for Stockfish initialization
+    const attemptStockfishAnalysis = async () => {
+      // Wait up to 3 seconds for Stockfish to be ready
+      let retries = 0
+      const maxRetries = 30 // 3 seconds with 100ms intervals
+      
+      while (retries < maxRetries && !isStockfishReady()) {
+        await new Promise(resolve => setTimeout(resolve, 100))
+        retries++
+      }
+      
+      if (!isStockfishReady()) {
+        console.warn('Stockfish not ready after waiting, skipping analysis')
+        return
+      }
+
+      const evaluationStream = streamEvaluations(
+        board.fen(),
+        board.moves().length,
+      )
 
-    if (evaluationStream) {
-      ;(async () => {
-        for await (const evaluation of evaluationStream) {
-          if (!currentNode) {
-            stopEvaluation()
-            break
+      if (evaluationStream) {
+        ;(async () => {
+          for await (const evaluation of evaluationStream) {
+            if (!currentNode) {
+              stopEvaluation()
+              break
+            }
+            currentNode.addStockfishAnalysis(evaluation, currentMaiaModel)
+            setAnalysisState((state) => state + 1)
           }
-          currentNode.addStockfishAnalysis(evaluation, currentMaiaModel)
-          setAnalysisState((state) => state + 1)
-        }
-      })()
+        })()
+      }
     }
 
+    attemptStockfishAnalysis()
+
     return () => {
       stopEvaluation()
     }
   }, [
     currentNode,
     streamEvaluations,
     stopEvaluation,
+    isStockfishReady,
     currentMaiaModel,
     setAnalysisState,
   ])

src/hooks/useStockfishEngine/engine.ts

@@ -9,6 +9,7 @@ class Engine {
   private moves: string[]
   private isEvaluating: boolean
   private stockfish: StockfishWeb | null = null
+  private isReady: boolean = false
 
   private store: {
     [key: string]: StockfishEvaluation
@@ -40,14 +41,22 @@ class Engine {
       stockfish.uci('setoption name MultiPV value 100')
       stockfish.onError = this.onError
       stockfish.listen = this.onMessage
+      this.isReady = true
+    }).catch((error) => {
+      console.error('Failed to initialize Stockfish:', error)
+      this.isReady = false
     })
   }
 
+  get ready(): boolean {
+    return this.isReady && this.stockfish !== null
+  }
+
   async *streamEvaluations(
     fen: string,
     legalMoveCount: number,
   ): AsyncGenerator<StockfishEvaluation> {
-    if (this.stockfish) {
+    if (this.stockfish && this.isReady) {
       if (typeof global.gc === 'function') {
         global.gc()
       }

src/hooks/useStockfishEngine/useStockfishEngine.ts

@@ -23,11 +23,16 @@ export const useStockfishEngine = () => {
     engineRef.current?.stopEvaluation()
   }, [])
 
+  const isReady = useCallback(() => {
+    return engineRef.current?.ready ?? false
+  }, [])
+
   return useMemo(
     () => ({
       streamEvaluations,
       stopEvaluation,
+      isReady,
     }),
-    [streamEvaluations, stopEvaluation],
+    [streamEvaluations, stopEvaluation, isReady],
   )
 }

src/pages/train.tsx

@@ -944,9 +944,7 @@ const Train: React.FC<Props> = ({
                     <span className="material-symbols-outlined mb-2 text-3xl text-human-3">
                       lock
                     </span>
-                    <p className="font-medium text-primary">
-                      Analysis Locked
-                    </p>
+                    <p className="font-medium text-primary">Analysis Locked</p>
                     <p className="text-sm text-secondary">
                       Complete the puzzle to unlock analysis
                     </p>