loukai-app 0.3.0

package/src/main/creator/keyDetection.js

@@ -0,0 +1,212 @@
+/**
+ * Musical Key Detection
+ * Detects the musical key from CREPE pitch data using Krumhansl-Schmuckler algorithm
+ */
+
+// Note names for output
+const NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+
+// Krumhansl-Schmuckler key profiles (normalized weights for each pitch class)
+// These represent how often each scale degree appears in typical major/minor music
+const MAJOR_PROFILE = [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88];
+const MINOR_PROFILE = [6.33, 2.68, 3.52, 5.38, 2.6, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17];
+
+/**
+ * Normalize an array so values sum to 1
+ */
+function normalize(arr) {
+  const sum = arr.reduce((a, b) => a + b, 0);
+  if (sum === 0) return arr.map(() => 0);
+  return arr.map((v) => v / sum);
+}
+
+/**
+ * Calculate Pearson correlation coefficient between two arrays
+ */
+function correlation(arr1, arr2) {
+  const n = arr1.length;
+  if (n !== arr2.length || n === 0) return 0;
+
+  const mean1 = arr1.reduce((a, b) => a + b, 0) / n;
+  const mean2 = arr2.reduce((a, b) => a + b, 0) / n;
+
+  let numerator = 0;
+  let sum1Sq = 0;
+  let sum2Sq = 0;
+
+  for (let i = 0; i < n; i++) {
+    const diff1 = arr1[i] - mean1;
+    const diff2 = arr2[i] - mean2;
+    numerator += diff1 * diff2;
+    sum1Sq += diff1 * diff1;
+    sum2Sq += diff2 * diff2;
+  }
+
+  const denominator = Math.sqrt(sum1Sq * sum2Sq);
+  if (denominator === 0) return 0;
+
+  return numerator / denominator;
+}
+
+/**
+ * Rotate array by n positions (for testing different root notes)
+ */
+function rotate(arr, n) {
+  const len = arr.length;
+  const shift = ((n % len) + len) % len;
+  return [...arr.slice(shift), ...arr.slice(0, shift)];
+}
+
+/**
+ * Detect musical key from CREPE pitch data
+ *
+ * @param {Object} pitchData - CREPE output with pitch_data containing midi array and confidence
+ * @param {number} confidenceThreshold - Minimum confidence to include a pitch (0-1)
+ * @returns {Object} { key: 'C major', confidence: 0.85, pitchHistogram: [...] }
+ */
+export function detectKey(pitchData, confidenceThreshold = 0.7) {
+  if (!pitchData?.pitch_data) {
+    return { key: 'unknown', confidence: 0, method: 'no_data' };
+  }
+
+  const { midi, confidence } = pitchData.pitch_data;
+
+  if (!midi || !confidence || midi.length === 0) {
+    return { key: 'unknown', confidence: 0, method: 'no_pitch_data' };
+  }
+
+  // Build pitch class histogram (0-11) from valid pitches
+  const pitchHistogram = new Array(12).fill(0);
+  let validCount = 0;
+
+  for (let i = 0; i < midi.length; i++) {
+    const midiNote = midi[i];
+    const conf = confidence[i];
+
+    // Skip low confidence or invalid pitches
+    if (conf < confidenceThreshold || midiNote <= 0 || !isFinite(midiNote)) {
+      continue;
+    }
+
+    // Get pitch class (0-11) from MIDI note
+    const pitchClass = Math.round(midiNote) % 12;
+    pitchHistogram[pitchClass]++;
+    validCount++;
+  }
+
+  if (validCount < 10) {
+    return { key: 'unknown', confidence: 0, method: 'insufficient_data' };
+  }
+
+  // Normalize histogram and profiles
+  const normalizedHistogram = normalize(pitchHistogram);
+  const normalizedMajor = normalize(MAJOR_PROFILE);
+  const normalizedMinor = normalize(MINOR_PROFILE);
+
+  // Test all 24 keys (12 major + 12 minor) and find best correlation
+  let bestKey = 'C';
+  let bestMode = 'major';
+  let bestCorrelation = -1;
+
+  for (let root = 0; root < 12; root++) {
+    // Test major key with this root
+    const shiftedMajor = rotate(normalizedMajor, root);
+    const corrMajor = correlation(normalizedHistogram, shiftedMajor);
+
+    if (corrMajor > bestCorrelation) {
+      bestCorrelation = corrMajor;
+      bestKey = NOTE_NAMES[root];
+      bestMode = 'major';
+    }
+
+    // Test minor key with this root
+    const shiftedMinor = rotate(normalizedMinor, root);
+    const corrMinor = correlation(normalizedHistogram, shiftedMinor);
+
+    if (corrMinor > bestCorrelation) {
+      bestCorrelation = corrMinor;
+      bestKey = NOTE_NAMES[root];
+      bestMode = 'minor';
+    }
+  }
+
+  const keyString = bestCorrelation > 0 ? `${bestKey} ${bestMode}` : 'unknown';
+
+  return {
+    key: keyString,
+    confidence: Math.max(0, bestCorrelation),
+    method: 'krumhansl_schmuckler',
+    pitchHistogram: pitchHistogram,
+    validPitchCount: validCount,
+  };
+}
+
+/**
+ * Convert key string to Camelot notation (used by DJs)
+ * e.g., "C major" -> "8B", "A minor" -> "8A"
+ */
+export function keyToCamelot(keyString) {
+  const camelotMap = {
+    'C major': '8B',
+    'G major': '9B',
+    'D major': '10B',
+    'A major': '11B',
+    'E major': '12B',
+    'B major': '1B',
+    'F# major': '2B',
+    'C# major': '3B',
+    'G# major': '4B',
+    'D# major': '5B',
+    'A# major': '6B',
+    'F major': '7B',
+    'A minor': '8A',
+    'E minor': '9A',
+    'B minor': '10A',
+    'F# minor': '11A',
+    'C# minor': '12A',
+    'G# minor': '1A',
+    'D# minor': '2A',
+    'A# minor': '3A',
+    'F minor': '4A',
+    'C minor': '5A',
+    'G minor': '6A',
+    'D minor': '7A',
+  };
+
+  return camelotMap[keyString] || '';
+}
+
+/**
+ * Convert key string to Open Key notation (alternative to Camelot)
+ * e.g., "C major" -> "1d", "A minor" -> "1m"
+ */
+export function keyToOpenKey(keyString) {
+  const openKeyMap = {
+    'C major': '1d',
+    'G major': '2d',
+    'D major': '3d',
+    'A major': '4d',
+    'E major': '5d',
+    'B major': '6d',
+    'F# major': '7d',
+    'C# major': '8d',
+    'G# major': '9d',
+    'D# major': '10d',
+    'A# major': '11d',
+    'F major': '12d',
+    'A minor': '1m',
+    'E minor': '2m',
+    'B minor': '3m',
+    'F# minor': '4m',
+    'C# minor': '5m',
+    'G# minor': '6m',
+    'D# minor': '7m',
+    'A# minor': '8m',
+    'F minor': '9m',
+    'C minor': '10m',
+    'G minor': '11m',
+    'D minor': '12m',
+  };
+
+  return openKeyMap[keyString] || '';
+}

package/src/main/creator/llmService.js

@@ -0,0 +1,370 @@
+/**
+ * LLM Service for lyrics correction
+ * Supports OpenAI, Anthropic Claude, Google Gemini, and local LM Studio
+ * Pure Node.js implementation
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { LLM_DEFAULTS } from '../../shared/defaults.js';
+
+/**
+ * Get LLM provider instance based on settings
+ */
+function getLLMProvider(settings) {
+  const { provider, apiKey, baseUrl } = settings;
+
+  switch (provider) {
+    case 'anthropic':
+      if (!apiKey) throw new Error('Anthropic API key required');
+      return new Anthropic({ apiKey });
+
+    case 'openai':
+      if (!apiKey) throw new Error('OpenAI API key required');
+      return new OpenAI({ apiKey });
+
+    case 'gemini':
+      if (!apiKey) throw new Error('Gemini API key required');
+      return new GoogleGenerativeAI(apiKey);
+
+    case 'lmstudio':
+      // LM Studio uses OpenAI-compatible API
+      return new OpenAI({
+        apiKey: 'lm-studio', // dummy key
+        baseURL: baseUrl || 'http://localhost:1234/v1',
+      });
+
+    default:
+      throw new Error(`Unknown LLM provider: ${provider}`);
+  }
+}
+
+/**
+ * Correct lyrics using LLM
+ * @param {Object} whisperOutput - Output from Whisper (words array)
+ * @param {string} referenceLyrics - Reference lyrics from LRCLIB
+ * @param {Object} settings - LLM settings (provider, model, apiKey, etc.)
+ * @returns {Object} Corrected lyrics with same structure as Whisper output
+ */
+export async function correctLyrics(whisperOutput, referenceLyrics, settings) {
+  if (!settings.enabled) {
+    console.log('🤖 LLM correction disabled, using Whisper output as-is');
+    return {
+      output: whisperOutput,
+      stats: null,
+    };
+  }
+
+  if (!referenceLyrics || !referenceLyrics.trim()) {
+    console.log('🤖 No reference lyrics provided, skipping LLM correction');
+    return {
+      output: whisperOutput,
+      stats: null,
+    };
+  }
+
+  console.log(`🤖 Starting LLM lyrics correction with ${settings.provider}...`);
+
+  try {
+    const provider = getLLMProvider(settings);
+    const llmResponse = await callLLM(provider, settings, whisperOutput, referenceLyrics);
+
+    // Parse JSON response and apply corrections
+    const {
+      lines: correctedLines,
+      corrections,
+      missingLines,
+    } = parseCorrection(llmResponse, whisperOutput);
+
+    console.log(`✅ LLM correction complete (${corrections.length} lines changed)`);
+    if (missingLines.length > 0) {
+      console.log(`📝 LLM suggested ${missingLines.length} missing lines`);
+    }
+
+    return {
+      output: {
+        ...whisperOutput,
+        lines: correctedLines,
+      },
+      stats: {
+        corrections_applied: corrections.length,
+        suggestions_made: corrections.length + missingLines.length, // Total suggestions (applied + not applied)
+        corrections_rejected: 0, // We auto-apply all matching corrections
+        missing_lines_suggested: missingLines.length,
+        corrections: corrections, // Detailed correction list (applied)
+        missing_lines: missingLines, // Detailed missing lines list (suggestions not applied)
+        failed: false,
+        provider: settings.provider,
+        model: settings.model,
+      },
+    };
+  } catch (error) {
+    console.error('❌ LLM correction failed:', error.message);
+    console.log('⚠️ Falling back to original Whisper output');
+    return {
+      output: whisperOutput,
+      stats: {
+        corrections_applied: 0,
+        suggestions_made: 0,
+        corrections_rejected: 0,
+        missing_lines_suggested: 0,
+        corrections: [],
+        missing_lines: [],
+        failed: true,
+        error: error.message,
+        provider: settings.provider,
+        model: settings.model,
+      },
+    };
+  }
+}
+
+/**
+ * Call LLM API with lyrics correction prompt
+ */
+async function callLLM(provider, settings, whisperOutput, referenceLyrics) {
+  const { provider: providerType, model } = settings;
+
+  // Build structured line data for LLM (work with lines, not words)
+  const lineData = whisperOutput.lines.map((line, i) => ({
+    line_num: i + 1,
+    text: line.text || '',
+    start: line.start,
+    end: line.end,
+  }));
+
+  // Build prompt
+  const systemPrompt = `You are an automated speech recognition (ASR) error correction specialist. You fix technical errors from speech-to-text systems while preserving the original transcription structure. Return ONLY valid JSON.`;
+
+  const userPrompt = `AUTOMATED SPEECH RECOGNITION (ASR) ERROR CORRECTION TASK
+
+CONTEXT: You are correcting errors from Whisper AI that transcribed sung vocals. The system sometimes mishears words due to singing pronunciation, background music, and audio quality.
+
+YOUR TASK: Fix ONLY obvious speech recognition errors where the ASR clearly misheard spoken/sung words.
+
+REFERENCE TEXT (for identifying ASR mishearings - DO NOT copy verbatim):
+${referenceLyrics}
+
+ASR OUTPUT TO CORRECT (song lines with timing):
+${JSON.stringify(lineData, null, 2)}
+
+CRITICAL RULES:
+1. ONLY correct obvious phonetic mishearings where automated speech recognition failed
+2. DO NOT substitute entire phrases even if they don't match the reference
+3. ONLY fix clear technical errors (e.g., "foamy" → "for me", "sancti" → "sanity")
+4. When in doubt, DO NOT fix - leave the line unchanged
+5. Return ONLY valid JSON, no markdown, no explanations
+
+RESPONSE FORMAT (MUST BE VALID JSON):
+{
+  "corrections": [
+    {"line_num": 1, "old_text": "original line", "new_text": "corrected line"}
+  ],
+  "missing_lines": [
+    {
+      "suggested_text": "Text of missing line from reference",
+      "start": 15.5,
+      "end": 19.5,
+      "confidence": "high|medium|low",
+      "reason": "Why this line is likely missing (e.g., 'Large gap in timing', 'Reference shows chorus missing')"
+    }
+  ]
+}
+
+IMPORTANT ABOUT MISSING LINES:
+- ONLY suggest missing lines if you have strong evidence:
+  1. Large timing gaps between transcribed lines (>4 seconds)
+  2. Reference lyrics having content that clearly fits in gaps
+- Set confidence based on evidence strength
+- DO NOT invent lyrics - only use what's in the reference
+- Return ONLY valid JSON, no markdown blocks, no additional text`;
+
+  // Call appropriate API
+  if (providerType === 'anthropic') {
+    const response = await provider.messages.create({
+      model: model || 'claude-3-5-sonnet-20241022',
+      max_tokens: 4096,
+      temperature: 0.1,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userPrompt }],
+    });
+    return response.content[0].text;
+  } else if (providerType === 'openai' || providerType === 'lmstudio') {
+    const response = await provider.chat.completions.create({
+      model: model || 'gpt-4o',
+      temperature: 0.1,
+      max_tokens: 16384,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt },
+      ],
+    });
+    return response.choices[0].message.content;
+  } else if (providerType === 'gemini') {
+    const genModel = provider.getGenerativeModel({
+      model: model || 'gemini-2.0-flash-exp',
+    });
+    const result = await genModel.generateContent({
+      contents: [{ role: 'user', parts: [{ text: `${systemPrompt}\n\n${userPrompt}` }] }],
+      generationConfig: {
+        temperature: 0.1,
+        maxOutputTokens: 4000,
+      },
+    });
+    return result.response.text();
+  }
+
+  throw new Error(`Unsupported provider: ${providerType}`);
+}
+
+/**
+ * Parse LLM JSON response and apply corrections to lines
+ * Preserves timing information from original Whisper output
+ * @returns {Object} { lines: correctedLines[], corrections: [], missingLines: [] }
+ */
+function parseCorrection(llmResponse, originalOutput) {
+  // Parse JSON response
+  let responseData;
+  try {
+    // Try to parse as-is
+    responseData = JSON.parse(llmResponse);
+  } catch {
+    // Try to extract JSON from markdown blocks
+    let cleaned = llmResponse.trim();
+    if (cleaned.includes('```json')) {
+      cleaned = cleaned.split('```json')[1].split('```')[0];
+    } else if (cleaned.includes('```')) {
+      cleaned = cleaned.split('```')[1].split('```')[0];
+    }
+
+    // Try to extract just the JSON object
+    const start = cleaned.indexOf('{');
+    const end = cleaned.lastIndexOf('}');
+    if (start !== -1 && end !== -1) {
+      cleaned = cleaned.substring(start, end + 1);
+    }
+
+    try {
+      responseData = JSON.parse(cleaned);
+    } catch (e2) {
+      console.error('Failed to parse LLM JSON response:', e2);
+      console.error('Response:', llmResponse.substring(0, 500));
+      throw new Error(`Invalid JSON response from LLM: ${e2.message}`);
+    }
+  }
+
+  const corrections = responseData.corrections || [];
+  const missingLines = responseData.missing_lines || [];
+
+  // Apply corrections to lines
+  const originalLines = originalOutput.lines || [];
+  const correctedLines = [...originalLines];
+  const appliedCorrections = [];
+
+  for (const correction of corrections) {
+    const lineNum = correction.line_num;
+    const oldText = correction.old_text || '';
+    const newText = correction.new_text || '';
+
+    const lineIdx = lineNum - 1;
+    if (lineIdx >= 0 && lineIdx < correctedLines.length) {
+      const originalLine = originalLines[lineIdx];
+      const originalText = originalLine.text || '';
+
+      // Only apply if old_text matches exactly
+      if (oldText === originalText && newText && newText !== originalText) {
+        correctedLines[lineIdx] = {
+          ...originalLine,
+          text: newText,
+        };
+
+        appliedCorrections.push({
+          line_num: lineNum,
+          old_text: oldText,
+          new_text: newText,
+        });
+      }
+    }
+  }
+
+  return {
+    lines: correctedLines,
+    corrections: appliedCorrections,
+    missingLines: missingLines,
+  };
+}
+
+/**
+ * Get LLM settings from app settings
+ * Uses unified defaults from shared/defaults.js
+ */
+export function getLLMSettings(settingsManager) {
+  const llmConfig = settingsManager.get('creator.llm', {});
+  const apiKey = llmConfig.apiKey || LLM_DEFAULTS.apiKey;
+
+  // SECURITY FIX (#25): Mask API key - only show last 4 chars to renderer
+  const maskedApiKey = apiKey && apiKey.length > 8 ? `${'•'.repeat(apiKey.length - 4)}${apiKey.slice(-4)}` : apiKey ? '••••••••' : '';
+
+  return {
+    enabled: llmConfig.enabled ?? LLM_DEFAULTS.enabled,
+    provider: llmConfig.provider || LLM_DEFAULTS.provider,
+    model: llmConfig.model || getDefaultModel(llmConfig.provider),
+    apiKey: maskedApiKey,
+    hasApiKey: Boolean(apiKey), // Let renderer know if key is set
+    baseUrl: llmConfig.baseUrl || LLM_DEFAULTS.baseUrl,
+  };
+}
+
+/**
+ * Save LLM settings
+ */
+export function saveLLMSettings(settingsManager, llmSettings) {
+  settingsManager.set('creator.llm', llmSettings);
+}
+
+/**
+ * Get default model for a provider
+ */
+function getDefaultModel(provider) {
+  const defaults = {
+    anthropic: 'claude-3-5-sonnet-20241022',
+    openai: 'gpt-4o',
+    gemini: 'gemini-2.0-flash-exp',
+    lmstudio: 'local-model',
+  };
+  return defaults[provider] || 'gpt-4o';
+}
+
+/**
+ * Test LLM connection
+ */
+export async function testLLMConnection(settings) {
+  try {
+    const provider = getLLMProvider(settings);
+
+    // Send simple test message
+    const testPrompt = 'Reply with just the word "OK"';
+
+    if (settings.provider === 'anthropic') {
+      await provider.messages.create({
+        model: settings.model,
+        max_tokens: 10,
+        messages: [{ role: 'user', content: testPrompt }],
+      });
+    } else if (settings.provider === 'openai' || settings.provider === 'lmstudio') {
+      await provider.chat.completions.create({
+        model: settings.model,
+        max_tokens: 10,
+        messages: [{ role: 'user', content: testPrompt }],
+      });
+    } else if (settings.provider === 'gemini') {
+      const genModel = provider.getGenerativeModel({ model: settings.model });
+      await genModel.generateContent(testPrompt);
+    }
+
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}