Fix depth configuration bug and add live node updates during analysis

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

Author: Copilot

src/hooks/useAnalysisController/useAnalysisController.ts

@@ -53,6 +53,7 @@ export const useAnalysisController = (
     game.tree,
     currentMaiaModel,
     setAnalysisState,
+    controller.setCurrentNode,
   )
 
   const availableMoves = useMemo(() => {

src/hooks/useAnalysisController/useGameAnalysis.ts

@@ -22,6 +22,7 @@ export const useGameAnalysis = (
   gameTree: GameTree | null,
   currentMaiaModel: string,
   setAnalysisState: React.Dispatch<React.SetStateAction<number>>,
+  setCurrentNode?: (node: GameNode) => void,
 ) => {
   const maia = useContext(MaiaEngineContext)
   const stockfish = useContext(StockfishEngineContext)
@@ -124,17 +125,27 @@ export const useGameAnalysis = (
       }
 
       // Analyze with Stockfish if not already at target depth
+      const shouldAnalyze =
+        !node.analysis.stockfish ||
+        node.analysis.stockfish.depth < config.targetDepth
+      console.log(
+        `Node analysis check - hasStockfish: ${!!node.analysis.stockfish}, currentDepth: ${node.analysis.stockfish?.depth || 'none'}, targetDepth: ${config.targetDepth}, shouldAnalyze: ${shouldAnalyze}`,
+      )
+
       if (
         !analysisController.current.cancelled &&
         stockfish.isReady() &&
-        (!node.analysis.stockfish ||
-          node.analysis.stockfish.depth < config.targetDepth)
+        shouldAnalyze
       ) {
         try {
           const chess = new Chess(node.fen)
+          console.log(
+            `Starting Stockfish analysis for node with target depth: ${config.targetDepth}`,
+          )
           const evaluationStream = stockfish.streamEvaluations(
             chess.fen(),
             chess.moves().length,
+            config.targetDepth,
           )
 
           if (evaluationStream) {
@@ -149,8 +160,15 @@ export const useGameAnalysis = (
               node.addStockfishAnalysis(evaluation, currentMaiaModel)
               setAnalysisState((state) => state + 1)
 
+              console.log(
+                `Received evaluation at depth ${evaluation.depth}, target: ${config.targetDepth}`,
+              )
+
               // Stop when we reach target depth
               if (evaluation.depth >= config.targetDepth) {
+                console.log(
+                  `Reached target depth ${config.targetDepth}, stopping analysis`,
+                )
                 break
               }
             }
@@ -218,6 +236,11 @@ export const useGameAnalysis = (
       const node = mainLine[i]
       analysisController.current.currentNode = node
 
+      // Update the UI to show the current node being analyzed (live update)
+      if (setCurrentNode) {
+        setCurrentNode(node)
+      }
+
       const moveDisplay = node.san || node.move || `Position ${i + 1}`
 
       setProgress((prev) => ({
@@ -238,7 +261,14 @@ export const useGameAnalysis = (
     }))
 
     analysisController.current.currentNode = null
-  }, [gameTree, progress.isAnalyzing, stockfish, maia.status, analyzeNode])
+  }, [
+    gameTree,
+    progress.isAnalyzing,
+    stockfish,
+    maia.status,
+    analyzeNode,
+    setCurrentNode,
+  ])
 
   const cancelAnalysis = useCallback(() => {
     analysisController.current.cancelled = true

src/providers/StockfishEngineContextProvider/StockfishEngineContextProvider.tsx

@@ -24,12 +24,12 @@ export const StockfishEngineContextProvider: React.FC<{
   }
 
   const streamEvaluations = useCallback(
-    (fen: string, legalMoveCount: number) => {
+    (fen: string, legalMoveCount: number, depth?: number) => {
       if (!engineRef.current) {
         console.error('Engine not initialized')
         return null
       }
-      return engineRef.current.streamEvaluations(fen, legalMoveCount)
+      return engineRef.current.streamEvaluations(fen, legalMoveCount, depth)
     },
     [],
   )

src/providers/StockfishEngineContextProvider/engine.ts

@@ -60,6 +60,7 @@ class Engine {
   async *streamEvaluations(
     fen: string,
     legalMoveCount: number,
+    targetDepth = 18,
   ): AsyncGenerator<StockfishEvaluation> {
     if (this.stockfish && this.isReady) {
       if (typeof global.gc === 'function') {
@@ -81,7 +82,7 @@ class Engine {
 
       this.sendMessage('ucinewgame')
       this.sendMessage(`position fen ${fen}`)
-      this.sendMessage('go depth 18')
+      this.sendMessage(`go depth ${targetDepth}`)
 
       while (this.isEvaluating) {
         try {

src/types/analysis/index.ts

@@ -17,6 +17,7 @@ export interface StockfishEngine {
   streamEvaluations: (
     fen: string,
     moveCount: number,
+    depth?: number,
   ) => AsyncIterable<StockfishEvaluation> | null
 }