fix(ai-director): исправлено отображение анализаторов в истории

Проблема: при загрузке завершенных анализов из storage показывалось
"Всего анализаторов: 0" и "Завершено: 0", хотя анализ был выполнен
полностью.

Решение:
- Добавлена функция extractAnalyzersFromResult() для извлечения
  списка выполненных анализаторов из ComprehensiveAnalysisResult
- Добавлена функция createFileProgressFromResult() для создания
  FileAnalysisProgress с правильно заполненной статистикой
- Обновлен use-timeline-analysis.ts для использования маппера
  при загрузке сохраненных анализов

Функция анализирует все поля результата:
- audio_analysis → audio_quality, speech_recognition
- scene_analysis → scene_detection (с количеством сцен)
- vision_analysis → object_detection, face_detection (с количеством)
- vision_language_model_analysis → vlm_analysis
- moment_analysis → moment_detection (с ключевыми моментами)
- content_analysis → content_classification, mood_analysis, quality_assessment

Теперь корректно отображается:
✅ Всего анализаторов: N
✅ Завершено: N
✅ Детали по каждому анализатору

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: chatman-media

src/features/ai-director/index.ts

@@ -62,7 +62,9 @@ export {
   ANALYZER_METADATA,
   calculateBatchProgress,
   calculateFileProgress,
+  createFileProgressFromResult,
   createInitialFileProgress,
+  extractAnalyzersFromResult,
   getAnalyzerMetadata,
   getAnalyzersByCategory,
   updateAnalyzerProgress,

src/features/ai-director/types/analysis-progress.ts

@@ -553,3 +553,167 @@ export function updateAnalyzerProgress(
     stats,
   }
 }
+
+/**
+ * Извлечь список анализаторов из ComprehensiveAnalysisResult
+ * Определяет какие анализаторы были выполнены на основе заполненных полей
+ */
+export function extractAnalyzersFromResult(
+  result: any, // ComprehensiveAnalysisResult from Rust
+): AnalyzerProgress[] {
+  const analyzers: AnalyzerProgress[] = []
+
+  // Audio analyzers
+  if (result.audio_analysis) {
+    analyzers.push({
+      type: "audio_quality",
+      status: "completed",
+      progress: 100,
+    })
+
+    // Если есть транскрипция
+    if (result.audio_analysis.transcription) {
+      analyzers.push({
+        type: "speech_recognition",
+        status: "completed",
+        progress: 100,
+      })
+    }
+  }
+
+  // Scene detection
+  if (result.scene_analysis && result.scene_analysis.scenes && result.scene_analysis.scenes.length > 0) {
+    analyzers.push({
+      type: "scene_detection",
+      status: "completed",
+      progress: 100,
+      result: {
+        type: "scene_detection",
+        success: true,
+        metadata: {
+          itemsFound: result.scene_analysis.scenes.length,
+          processingTime: 0,
+        },
+      },
+    })
+  }
+
+  // Vision analysis (objects, faces)
+  if (result.vision_analysis) {
+    if (result.vision_analysis.objects_detected && result.vision_analysis.objects_detected.length > 0) {
+      analyzers.push({
+        type: "object_detection",
+        status: "completed",
+        progress: 100,
+        result: {
+          type: "object_detection",
+          success: true,
+          metadata: {
+            itemsFound: result.vision_analysis.objects_detected.length,
+            processingTime: 0,
+          },
+        },
+      })
+    }
+
+    if (result.vision_analysis.faces_count > 0) {
+      analyzers.push({
+        type: "face_detection",
+        status: "completed",
+        progress: 100,
+        result: {
+          type: "face_detection",
+          success: true,
+          metadata: {
+            itemsFound: result.vision_analysis.faces_count,
+            processingTime: 0,
+          },
+        },
+      })
+    }
+  }
+
+  // Vision Language Model analysis
+  if (result.vision_language_model_analysis) {
+    analyzers.push({
+      type: "vlm_analysis",
+      status: "completed",
+      progress: 100,
+    })
+  }
+
+  // Moment detection
+  if (result.moment_analysis && result.moment_analysis.key_moments && result.moment_analysis.key_moments.length > 0) {
+    analyzers.push({
+      type: "moment_detection",
+      status: "completed",
+      progress: 100,
+      result: {
+        type: "moment_detection",
+        success: true,
+        metadata: {
+          itemsFound: result.moment_analysis.key_moments.length,
+          processingTime: 0,
+        },
+      },
+    })
+  }
+
+  // Content analysis
+  if (result.content_analysis) {
+    analyzers.push({
+      type: "content_classification",
+      status: "completed",
+      progress: 100,
+    })
+
+    if (result.content_analysis.mood) {
+      analyzers.push({
+        type: "mood_analysis",
+        status: "completed",
+        progress: 100,
+      })
+    }
+
+    if (result.content_analysis.quality) {
+      analyzers.push({
+        type: "quality_assessment",
+        status: "completed",
+        progress: 100,
+      })
+    }
+  }
+
+  return analyzers
+}
+
+/**
+ * Создать FileAnalysisProgress из ComprehensiveAnalysisResult
+ * Используется при загрузке сохраненных анализов из storage
+ */
+export function createFileProgressFromResult(
+  result: any, // ComprehensiveAnalysisResult from Rust
+  filePath: string,
+): FileAnalysisProgress {
+  const fileName = filePath.split("/").pop() || filePath.split("\\").pop() || filePath
+  const analyzers = extractAnalyzersFromResult(result)
+
+  return {
+    id: result.analysis_id,
+    fileId: result.analysis_id,
+    fileName,
+    filePath,
+    status: result.status === "Completed" ? "completed" : "error",
+    progress: 100,
+    analyzers,
+    stats: {
+      totalAnalyzers: analyzers.length,
+      completedAnalyzers: analyzers.filter((a) => a.status === "completed").length,
+      failedAnalyzers: analyzers.filter((a) => a.status === "error").length,
+      skippedAnalyzers: analyzers.filter((a) => a.status === "skipped").length,
+    },
+    startTime: result.started_at,
+    endTime: result.completed_at,
+    duration: result.total_duration_ms,
+  }
+}

src/features/timeline/hooks/state/use-timeline-analysis.ts

@@ -12,6 +12,7 @@ import { useCallback, useEffect, useMemo, useState } from "react"
 
 import { analysisStorageService } from "@/domains/ai-services/services/analysis-storage-service"
 import { useMediaFiles } from "@/domains/project-management/hooks"
+import { createFileProgressFromResult } from "@/features/ai-director"
 import { useAIDirectorAnalysisV2 } from "@/features/ai-director/hooks/use-ai-director-analysis-v2"
 import type {
   AnalyzerType,
@@ -85,27 +86,9 @@ export function useTimelineAnalysis(): UseTimelineAnalysisReturn {
           const result = await analysisStorageService.loadComprehensiveAnalysis(videoPath)
 
           if (result.success && result.data) {
-            const fileName = videoPath.split("/").pop() || videoPath.split("\\").pop() || videoPath
-
             // Создаем FileAnalysisProgress из сохраненного анализа
-            const fileProgress: FileAnalysisProgress = {
-              id: result.data.analysis_id,
-              fileId: result.data.analysis_id,
-              fileName,
-              filePath: videoPath,
-              status: "completed" as FileAnalysisStatus,
-              progress: 100,
-              analyzers: [],
-              stats: {
-                totalAnalyzers: 0,
-                completedAnalyzers: 0,
-                failedAnalyzers: 0,
-                skippedAnalyzers: 0,
-              },
-              startTime: result.data.started_at,
-              endTime: result.data.completed_at,
-            }
-
+            // Используем маппер для извлечения анализаторов из результата
+            const fileProgress = createFileProgressFromResult(result.data, videoPath)
             analyses.push(fileProgress)
           }
         }