feat: load engine analysis from backend

Author: kevinjosethomas

src/api/analysis/analysis.ts

@@ -700,7 +700,7 @@ export const storeEngineAnalysis = async (
 // Retrieve stored engine analysis from backend
 export const getEngineAnalysis = async (
   gameId: string,
-): Promise<EngineAnalysisPosition[] | null> => {
+): Promise<{ positions: EngineAnalysisPosition[] } | null> => {
   const res = await fetch(buildUrl(`analysis/get_engine_analysis/${gameId}`))
 
   if (res.status === 401) {

src/hooks/useAnalysisController/useAnalysisController.ts

@@ -22,8 +22,12 @@ import { StockfishEngineContext } from 'src/contexts/StockfishEngineContext'
 import {
   collectEngineAnalysisData,
   generateAnalysisCacheKey,
+  applyEngineAnalysisData,
 } from 'src/lib/analysisStorage'
-import { storeEngineAnalysis } from 'src/api/analysis/analysis'
+import {
+  storeEngineAnalysis,
+  getEngineAnalysis,
+} from 'src/api/analysis/analysis'
 
 export interface GameAnalysisProgress {
   currentMoveIndex: number
@@ -128,6 +132,51 @@ export const useAnalysisController = (
   const saveAnalysisToBackendRef = useRef(saveAnalysisToBackend)
   saveAnalysisToBackendRef.current = saveAnalysisToBackend
 
+  const loadStoredAnalysis = useCallback(async () => {
+    console.log(
+      'loadStoredAnalysis called for game:',
+      game.id,
+      'type:',
+      game.type,
+    )
+
+    if (
+      !game.id ||
+      game.type === 'custom-pgn' ||
+      game.type === 'custom-fen' ||
+      game.type === 'tournament'
+    ) {
+      console.log('Skipping analysis load - game not eligible')
+      return
+    }
+
+    try {
+      console.log('Fetching stored analysis for game:', game.id)
+      const storedAnalysis = await getEngineAnalysis(game.id)
+      console.log('Received stored analysis:', storedAnalysis)
+
+      if (storedAnalysis && storedAnalysis.positions.length > 0) {
+        applyEngineAnalysisData(game.tree, storedAnalysis.positions)
+        setAnalysisState((prev) => prev + 1) // Trigger UI updates
+        console.log(
+          'Loaded stored analysis:',
+          storedAnalysis.positions.length,
+          'positions',
+        )
+      } else {
+        console.log('No stored analysis found for game:', game.id)
+      }
+    } catch (error) {
+      console.warn('Failed to load stored analysis:', error)
+      // Don't show error to user as this is background functionality
+    }
+  }, [game.id, game.type])
+
+  // Load stored analysis when game changes
+  useEffect(() => {
+    loadStoredAnalysis()
+  }, [loadStoredAnalysis])
+
   // Setup auto-save timer
   useEffect(() => {
     // Clear existing timer
@@ -431,6 +480,7 @@ export const useAnalysisController = (
       resetProgress: resetGameAnalysisProgress,
       isEnginesReady: stockfish.isReady() && maia.status === 'ready',
       saveAnalysis: saveAnalysisToBackend,
+      loadStoredAnalysis,
     },
   }
 }

src/lib/analysisStorage.ts

@@ -1,5 +1,7 @@
-import { GameTree, GameNode } from 'src/types'
+import { Chess } from 'chess.ts'
+import { GameTree } from 'src/types'
 import { EngineAnalysisPosition } from 'src/api/analysis/analysis'
+import { cpToWinrate } from 'src/lib/stockfish'
 
 /**
  * Collects analysis data from a game tree to send to the backend
@@ -63,18 +65,11 @@ export const applyEngineAnalysisData = (
 
         // Apply Stockfish analysis
         if (stockfish) {
-          // Create a StockfishEvaluation object with minimal required fields
-          const stockfishEval = {
-            sent: true,
-            depth: stockfish.depth,
-            model_move: Object.keys(stockfish.cp_vec)[0] || '',
-            model_optimal_cp: Math.max(
-              ...Object.values(stockfish.cp_vec).map(Number),
-              0,
-            ),
-            cp_vec: stockfish.cp_vec,
-            cp_relative_vec: calculateRelativeCp(stockfish.cp_vec),
-          }
+          const stockfishEval = reconstructStockfishEvaluation(
+            stockfish.cp_vec,
+            stockfish.depth,
+            node.fen,
+          )
 
           // Only apply if we don't have deeper analysis already
           if (
@@ -90,19 +85,87 @@ export const applyEngineAnalysisData = (
 }
 
 /**
- * Helper function to calculate relative centipawn values
+ * Reconstruct a complete StockfishEvaluation from stored cp_vec using the same logic as the engine
  */
-const calculateRelativeCp = (cpVec: {
-  [move: string]: number
-}): { [move: string]: number } => {
-  const maxCp = Math.max(...Object.values(cpVec))
-  const relativeCp: { [move: string]: number } = {}
-
-  Object.entries(cpVec).forEach(([move, cp]) => {
-    relativeCp[move] = cp - maxCp
-  })
-
-  return relativeCp
+const reconstructStockfishEvaluation = (
+  cpVec: { [move: string]: number },
+  depth: number,
+  fen: string,
+) => {
+  const board = new Chess(fen)
+  const isBlackTurn = board.turn() === 'b'
+
+  // Find the best move and cp (model_move and model_optimal_cp)
+  let bestCp = isBlackTurn ? Infinity : -Infinity
+  let bestMove = ''
+
+  for (const move in cpVec) {
+    const cp = cpVec[move]
+    if (isBlackTurn) {
+      if (cp < bestCp) {
+        bestCp = cp
+        bestMove = move
+      }
+    } else {
+      if (cp > bestCp) {
+        bestCp = cp
+        bestMove = move
+      }
+    }
+  }
+
+  // Calculate cp_relative_vec using exact same logic as engine.ts:215-217
+  const cp_relative_vec: { [move: string]: number } = {}
+  for (const move in cpVec) {
+    const cp = cpVec[move]
+    cp_relative_vec[move] = isBlackTurn
+      ? bestCp - cp // Black turn: model_optimal_cp - cp
+      : cp - bestCp // White turn: cp - model_optimal_cp
+  }
+
+  // Calculate winrate_vec using exact same logic as engine.ts:219 and 233
+  const winrate_vec: { [move: string]: number } = {}
+  for (const move in cpVec) {
+    const cp = cpVec[move]
+    // Use exact same logic as engine: cp * (isBlackTurn ? -1 : 1)
+    const winrate = cpToWinrate(cp * (isBlackTurn ? -1 : 1), false)
+    winrate_vec[move] = winrate
+  }
+
+  // Calculate winrate_loss_vec using the same logic as the engine (lines 248-264)
+  let bestWinrate = -Infinity
+  for (const move in winrate_vec) {
+    const wr = winrate_vec[move]
+    if (wr > bestWinrate) {
+      bestWinrate = wr
+    }
+  }
+
+  const winrate_loss_vec: { [move: string]: number } = {}
+  for (const move in winrate_vec) {
+    winrate_loss_vec[move] = winrate_vec[move] - bestWinrate
+  }
+
+  // Sort all vectors by winrate (descending) as done in engine.ts:267-281
+  const sortedEntries = Object.entries(winrate_vec).sort(
+    ([, a], [, b]) => b - a,
+  )
+
+  const sortedWinrateVec = Object.fromEntries(sortedEntries)
+  const sortedWinrateLossVec = Object.fromEntries(
+    sortedEntries.map(([move]) => [move, winrate_loss_vec[move]]),
+  )
+
+  return {
+    sent: true,
+    depth,
+    model_move: bestMove,
+    model_optimal_cp: bestCp,
+    cp_vec: cpVec,
+    cp_relative_vec,
+    winrate_vec: sortedWinrateVec,
+    winrate_loss_vec: sortedWinrateLossVec,
+  }
 }
 
 /**