Add speaker name detection feature

- Add LLM-based speaker name detection using LangChain prompts
- Only replace speaker IDs with high-confidence name detections
- Add 'Detect Speaker Names' button (only enabled with diarization)
- Update transcript rendering to show detected names
- Add API endpoint /api/detect-speaker-names
- Add SpeakerNameDetectionRequest model
- Update frontend state management for speaker names

frontend/app.js

@@ -4,6 +4,7 @@ const state = {
   utterances: [],
   diarizedUtterances: null,
   diarizationStats: null,
+  speakerNames: {}, // Maps speaker_id to detected name info
   summary: '',
   title: '',
   audioUrl: null,
@@ -11,6 +12,7 @@ const state = {
   uploadedFile: null,
   transcribing: false,
   summarizing: false,
+  detectingSpeakerNames: false,
 };
 
 const elements = {
@@ -29,6 +31,7 @@ const elements = {
   sensevoiceLanguage: document.getElementById('sensevoice-language'),
   transcribeBtn: document.getElementById('transcribe-btn'),
   summaryBtn: document.getElementById('summary-btn'),
+  detectSpeakerNamesBtn: document.getElementById('detect-speaker-names-btn'),
   statusText: document.getElementById('status-text'),
   audioPlayer: document.getElementById('audio-player'),
   transcriptList: document.getElementById('transcript-list'),
@@ -334,7 +337,13 @@ function renderTranscript() {
 
     const speakerTag = node.querySelector('.speaker-tag');
     if (typeof utt.speaker === 'number') {
-      speakerTag.textContent = `Speaker ${utt.speaker + 1}`;
+      const speakerId = utt.speaker;
+      const speakerName = state.speakerNames[speakerId]?.name;
+      if (speakerName) {
+        speakerTag.textContent = speakerName;
+      } else {
+        speakerTag.textContent = `Speaker ${speakerId + 1}`;
+      }
       speakerTag.classList.remove('hidden');
     }
 
@@ -347,9 +356,11 @@ function renderTranscript() {
 function renderDiarizationStats() {
   if (!state.diarizationStats) {
     elements.diarizationPanel.classList.add('hidden');
+    elements.detectSpeakerNamesBtn.classList.add('hidden');
     return;
   }
   elements.diarizationPanel.classList.remove('hidden');
+  elements.detectSpeakerNamesBtn.classList.remove('hidden');
   const stats = state.diarizationStats;
 
   elements.diarizationMetrics.innerHTML = '';
@@ -544,6 +555,47 @@ async function handleSummaryGeneration() {
   }
 }
 
+async function handleSpeakerNameDetection() {
+  if (state.detectingSpeakerNames || !state.diarizationStats) return;
+
+  state.detectingSpeakerNames = true;
+  setStatus('Detecting speaker names...', 'info');
+
+  const payload = {
+    utterances: state.utterances,
+    llm_model: elements.llmSelect.value,
+  };
+
+  try {
+    const response = await fetch('/api/detect-speaker-names', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) throw new Error('Failed to detect speaker names');
+
+    const speakerNames = await response.json();
+    state.speakerNames = speakerNames;
+
+    // Re-render transcript to show detected names
+    renderTranscript();
+
+    const detectedCount = Object.keys(speakerNames).length;
+    if (detectedCount > 0) {
+      setStatus(`Detected names for ${detectedCount} speaker(s)`, 'success');
+    } else {
+      setStatus('No speaker names could be confidently detected', 'info');
+    }
+
+  } catch (err) {
+    console.error(err);
+    setStatus(err.message, 'error');
+  } finally {
+    state.detectingSpeakerNames = false;
+  }
+}
+
 async function handleExportTranscript() {
   if (!state.utterances.length) return;
   const payload = {
@@ -721,79 +773,11 @@ async function downloadEpisode(audioUrl, title, triggerButton = null) {
     state.uploadedFile = null;
     elements.audioPlayer.src = data.audioUrl;
     setStatus('Episode ready', 'success');
-    if (triggerButton) {
-      triggerButton.textContent = 'Ready ✓';
-      triggerButton.classList.add('success');
-    }
   } catch (err) {
     console.error(err);
     setStatus(err.message, 'error');
-    if (triggerButton) {
-      triggerButton.textContent = 'Retry';
-      triggerButton.classList.add('error');
-    }
   } finally {
-    if (triggerButton) {
-      triggerButton.disabled = false;
-      triggerButton.classList.remove('loading');
-      setTimeout(() => {
-        triggerButton.classList.remove('success', 'error');
-        triggerButton.textContent = originalLabel || 'Download';
-      }, 2000);
-    }
+    triggerButton.classList.remove('loading');
+    triggerButton.textContent = 'Download';
   }
 }
-
-function initPodcastInteractions() {
-  elements.podcastResults.addEventListener('click', (event) => {
-    const btn = event.target.closest('button[data-feed]');
-    if (!btn) return;
-    const listItem = btn.closest('.list-item');
-    loadEpisodes(btn.dataset.feed, listItem);
-  });
-
-  elements.episodeResults.addEventListener('click', (event) => {
-    const btn = event.target.closest('button[data-url]');
-    if (!btn) return;
-    downloadEpisode(btn.dataset.url, btn.dataset.title, btn);
-  });
-
-}
-
-function initEventBindings() {
-  elements.transcribeBtn.addEventListener('click', handleTranscription);
-  elements.summaryBtn.addEventListener('click', handleSummaryGeneration);
-  elements.exportTranscriptBtn.addEventListener('click', handleExportTranscript);
-  elements.exportSummaryBtn.addEventListener('click', handleExportSummary);
-  elements.fileInput.addEventListener('change', handleFileUpload);
-  elements.youtubeFetch.addEventListener('click', handleYoutubeFetch);
-  elements.podcastSearch.addEventListener('click', handlePodcastSearch);
-  elements.podcastQuery.addEventListener('keydown', (event) => {
-    if (event.key === 'Enter') {
-      event.preventDefault();
-      handlePodcastSearch();
-    }
-  });
-}
-
-async function init() {
-  initTabs();
-  initSidebarInteractions();
-  initAudioInteractions();
-  initEventBindings();
-  initPodcastInteractions();
-
-  elements.backendSelect.innerHTML = `
-    <option value="moonshine">Moonshine</option>
-    <option value="sensevoice" selected>SenseVoice</option>
-  `;
-  state.backend = elements.backendSelect.value;
-
-  setListEmpty(elements.podcastResults, 'Search to discover podcasts.');
-  setListEmpty(elements.episodeResults, 'Select a podcast to view episodes.');
-
-  await fetchConfig();
-  setStatus('Ready');
-}
-
-init();

frontend/index.html

@@ -123,6 +123,7 @@
         <section id="results-tab" class="tab-panel">
           <div class="actions">
             <button id="transcribe-btn" class="primary">Transcribe Audio</button>
+            <button id="detect-speaker-names-btn" class="secondary hidden">Detect Speaker Names</button>
             <button id="summary-btn" class="secondary">Generate Summary</button>
             <span id="status-text" class="status-text">Ready</span>
           </div>

src/server/models/summarization.py

@@ -8,3 +8,8 @@ class SummaryRequest(BaseModel):
     llm_model: str
     prompt: str = Field("Summarize the transcript below.")
     generate_title: bool = Field(default=True)
+
+
+class SpeakerNameDetectionRequest(BaseModel):
+    utterances: list = Field(..., min_length=1)
+    llm_model: str

src/server/routers/api.py

@@ -7,7 +7,7 @@ from fastapi import APIRouter, File, Form, HTTPException, UploadFile
 from fastapi.responses import StreamingResponse
 
 from ..models.export import SummaryExportRequest, TranscriptExportRequest
-from ..models.summarization import SummaryRequest
+from ..models.summarization import SummaryRequest, SpeakerNameDetectionRequest
 from ..models.transcription import TranscriptionRequest
 from ..core.config import get_settings
 from ..services import config_service, export_service, podcast_service
@@ -119,3 +119,10 @@ def export_summary(payload: SummaryExportRequest):
         media_type=mime_type,
         headers={"Content-Disposition": content_disposition},
     )
+
+
+@router.post("/detect-speaker-names")
+def detect_speaker_names(request: SpeakerNameDetectionRequest):
+    from src.summarization import detect_speaker_names as detect_names
+    result = detect_names(request.utterances, request.llm_model)
+    return result

src/summarization.py

@@ -266,6 +266,122 @@ def generate_title(transcript: str, selected_gguf_model: str) -> str:
         return "Untitled Document"
 
 
+def create_speaker_name_detection_prompt() -> PromptTemplate:
+    """Prompt for detecting speaker names from their utterances"""
+    template = """Analyze the following utterances from a single speaker and suggest a name for this speaker. Look for:
+
+1. Self-introductions or self-references
+2. Names mentioned in context
+3. Speech patterns, vocabulary, and topics that might indicate identity
+4. Professional titles, roles, or relationships mentioned
+
+Utterances from this speaker:
+{text}
+
+Based on the content, suggest a name for this speaker. Consider:
+- If the speaker introduces themselves, use that name
+- If the speaker is addressed by others, use that name
+- If the content suggests a clear identity (e.g., "I'm Dr. Smith", "As CEO", "My name is John")
+- If no clear name is evident, suggest "Unknown"
+
+Provide your answer in this exact format:
+NAME: [suggested name]
+CONFIDENCE: [high/medium/low]
+REASON: [brief explanation]
+
+If confidence is "low", the name should not be used."""
+    return PromptTemplate(template=template, input_variables=["text"])
+
+
+def detect_speaker_names(utterances: list, selected_gguf_model: str) -> dict:
+    """
+    Detect speaker names from diarized utterances using LLM analysis.
+
+    Args:
+        utterances: List of utterance dicts with 'speaker', 'text', 'start', 'end' keys
+        selected_gguf_model: The LLM model to use for analysis
+
+    Returns:
+        Dict mapping speaker_id to detected name info:
+        {
+            speaker_id: {
+                'name': str,
+                'confidence': str,  # 'high', 'medium', 'low'
+                'reason': str
+            }
+        }
+    """
+    if not utterances:
+        return {}
+
+    # Group utterances by speaker
+    speaker_utterances = {}
+    for utt in utterances:
+        speaker_id = utt.get('speaker')
+        if speaker_id is not None:
+            if speaker_id not in speaker_utterances:
+                speaker_utterances[speaker_id] = []
+            speaker_utterances[speaker_id].append(utt['text'])
+
+    if not speaker_utterances:
+        return {}
+
+    try:
+        llm = get_llm(selected_gguf_model)
+        prompt = create_speaker_name_detection_prompt()
+
+        speaker_names = {}
+
+        for speaker_id, texts in speaker_utterances.items():
+            # Combine all utterances for this speaker (limit to reasonable length)
+            combined_text = ' '.join(texts)
+            if len(combined_text) > 4000:  # Limit context
+                combined_text = combined_text[:4000] + '...'
+
+            # Format prompt
+            formatted_prompt = prompt.format(text=combined_text)
+
+            # Get LLM response
+            response = llm.create_chat_completion(
+                messages=[
+                    {"role": "system", "content": "You are an expert at analyzing speech patterns and identifying speaker identities from transcripts. Be precise and only suggest names when you have clear evidence."},
+                    {"role": "user", "content": formatted_prompt}
+                ],
+                stream=False,
+                max_tokens=100,
+            )
+
+            result_text = response['choices'][0]['message']['content'].strip()
+
+            # Parse the response
+            name = "Unknown"
+            confidence = "low"
+            reason = "No clear identification found"
+
+            lines = result_text.split('\n')
+            for line in lines:
+                if line.startswith('NAME:'):
+                    name = line.replace('NAME:', '').strip()
+                elif line.startswith('CONFIDENCE:'):
+                    confidence = line.replace('CONFIDENCE:', '').strip().lower()
+                elif line.startswith('REASON:'):
+                    reason = line.replace('REASON:', '').strip()
+
+            # Only include high confidence detections
+            if confidence == 'high' and name != "Unknown":
+                speaker_names[speaker_id] = {
+                    'name': name,
+                    'confidence': confidence,
+                    'reason': reason
+                }
+
+        return speaker_names
+
+    except Exception as e:
+        print(f"Error detecting speaker names: {e}")
+        return {}
+
+
 # Alias pour maintenir la compatibilité
 summarize_transcript = summarize_transcript_langchain