Final implementation with improved error handling and formatting

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

Author: Copilot

src/api/analysis/analysis.ts

@@ -683,13 +683,16 @@ export const storeEngineAnalysis = async (
   gameId: string,
   analysisData: EngineAnalysisData,
 ): Promise<void> => {
-  const res = await fetch(buildUrl(`analysis/store_engine_analysis/${gameId}`), {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
+  const res = await fetch(
+    buildUrl(`analysis/store_engine_analysis/${gameId}`),
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(analysisData),
     },
-    body: JSON.stringify(analysisData),
-  })
+  )
 
   if (res.status === 401) {
     throw new Error('Unauthorized')

src/hooks/useAnalysisController/useAnalysisController.ts

@@ -19,9 +19,9 @@ import { useMoveRecommendations } from './useMoveRecommendations'
 import { MaiaEngineContext } from 'src/contexts/MaiaEngineContext'
 import { generateColorSanMapping, calculateBlunderMeter } from './utils'
 import { StockfishEngineContext } from 'src/contexts/StockfishEngineContext'
-import { 
-  collectEngineAnalysisData, 
-  generateAnalysisCacheKey 
+import {
+  collectEngineAnalysisData,
+  generateAnalysisCacheKey,
 } from 'src/lib/analysisStorage'
 import { storeEngineAnalysis } from 'src/api/analysis/analysis'
 
@@ -92,12 +92,21 @@ export const useAnalysisController = (
 
     try {
       const analysisData = collectEngineAnalysisData(game.tree)
-      
+
       // Only save if there's actually some analysis to save
       if (analysisData.positions.length === 0) {
         return
       }
 
+      // Check if we have meaningful analysis (decent depth or Maia data)
+      const hasMeaningfulAnalysis = analysisData.positions.some(
+        (pos) => (pos.stockfish && pos.stockfish.depth >= 12) || pos.maia,
+      )
+
+      if (!hasMeaningfulAnalysis) {
+        return
+      }
+
       // Generate a cache key to avoid unnecessary saves
       const cacheKey = generateAnalysisCacheKey(analysisData)
       if (cacheKey === lastSavedCacheKey) {
@@ -106,7 +115,11 @@ export const useAnalysisController = (
 
       await storeEngineAnalysis(game.id, analysisData)
       setLastSavedCacheKey(cacheKey)
-      console.log('Analysis saved to backend:', analysisData.positions.length, 'positions')
+      console.log(
+        'Analysis saved to backend:',
+        analysisData.positions.length,
+        'positions',
+      )
     } catch (error) {
       console.warn('Failed to save analysis to backend:', error)
       // Don't show error to user as this is background functionality
@@ -123,11 +136,13 @@ export const useAnalysisController = (
     // Set up new timer to save every 10 seconds
     autoSaveTimerRef.current = setInterval(saveAnalysisToBackend, 10000)
 
-    // Cleanup on unmount
+    // Cleanup on unmount or game change - save one last time
     return () => {
       if (autoSaveTimerRef.current) {
         clearInterval(autoSaveTimerRef.current)
       }
+      // Final save when component unmounts or game changes
+      saveAnalysisToBackend()
     }
   }, [saveAnalysisToBackend])
 
@@ -418,6 +433,7 @@ export const useAnalysisController = (
       cancelAnalysis: cancelGameAnalysis,
       resetProgress: resetGameAnalysisProgress,
       isEnginesReady: stockfish.isReady() && maia.status === 'ready',
+      saveAnalysis: saveAnalysisToBackend,
     },
   }
 }

src/lib/analysisStorage.ts

@@ -73,7 +73,10 @@ export const applyEngineAnalysisData = (
             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),
+            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),
           }
@@ -110,16 +113,18 @@ const calculateRelativeCp = (cpVec: {
 /**
  * Generate a unique cache key for analysis data
  */
-export const generateAnalysisCacheKey = (analysisData: EngineAnalysisData): string => {
+export const generateAnalysisCacheKey = (
+  analysisData: EngineAnalysisData,
+): string => {
   // Create a hash-like key based on positions and their analysis
-  const keyData = analysisData.positions.map(pos => ({
+  const keyData = analysisData.positions.map((pos) => ({
     ply: pos.ply,
     fen: pos.fen,
     hasStockfish: !!pos.stockfish,
     stockfishDepth: pos.stockfish?.depth || 0,
     hasMaia: !!pos.maia,
-    maiaModels: pos.maia ? Object.keys(pos.maia).sort() : []
+    maiaModels: pos.maia ? Object.keys(pos.maia).sort() : [],
   }))
-  
+
   return JSON.stringify(keyData)
-}
+}

src/pages/analysis/[...id].tsx

@@ -88,7 +88,11 @@ const AnalysisPage: NextPage = () => {
       const storedAnalysis = await getEngineAnalysis(game.id)
       if (storedAnalysis && storedAnalysis.positions.length > 0) {
         applyEngineAnalysisData(game.tree, storedAnalysis)
-        console.log('Loaded stored analysis:', storedAnalysis.positions.length, 'positions')
+        console.log(
+          'Loaded stored analysis:',
+          storedAnalysis.positions.length,
+          'positions',
+        )
       }
     } catch (error) {
       console.warn('Failed to load stored analysis:', error)