loukai-app 0.3.0

package/src/shared/services/creatorService.test.js

@@ -0,0 +1,413 @@
+/**
+ * Creator Service Tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// Mock all external dependencies before importing the service
+vi.mock('../../main/creator/systemChecker.js', () => ({
+  checkAllComponents: vi.fn(),
+  getCacheDir: vi.fn(() => '/mock/cache/dir'),
+  getPythonPath: vi.fn(() => '/mock/python'),
+}));
+
+vi.mock('../../main/creator/downloadManager.js', () => ({
+  installAllComponents: vi.fn(),
+}));
+
+vi.mock('../../main/creator/lrclibService.js', () => ({
+  searchLyrics: vi.fn(),
+  prepareWhisperContext: vi.fn(),
+}));
+
+vi.mock('../../main/creator/ffmpegService.js', () => ({
+  getAudioInfo: vi.fn(),
+  isVideoFile: vi.fn(),
+}));
+
+vi.mock('../../main/creator/conversionService.js', () => ({
+  runConversion: vi.fn(),
+  cancelConversion: vi.fn(),
+  isConversionInProgress: vi.fn(() => false),
+}));
+
+describe('creatorService', () => {
+  let creatorService;
+  let checkAllComponents;
+  let _getCacheDir;
+  let _getPythonPath;
+  let installAllComponents;
+  let searchLyrics;
+  let prepareWhisperContext;
+  let getAudioInfo;
+  let isVideoFile;
+  let runConversion;
+  let cancelConversion;
+  let isConversionInProgress;
+
+  beforeEach(async () => {
+    // Reset modules to clear module-level state (installationInProgress, etc.)
+    vi.resetModules();
+
+    // Re-import mocks and service fresh
+    const systemChecker = await import('../../main/creator/systemChecker.js');
+    checkAllComponents = systemChecker.checkAllComponents;
+    _getCacheDir = systemChecker.getCacheDir;
+    _getPythonPath = systemChecker.getPythonPath;
+
+    const downloadManager = await import('../../main/creator/downloadManager.js');
+    installAllComponents = downloadManager.installAllComponents;
+
+    const lrclibService = await import('../../main/creator/lrclibService.js');
+    searchLyrics = lrclibService.searchLyrics;
+    prepareWhisperContext = lrclibService.prepareWhisperContext;
+
+    const ffmpegService = await import('../../main/creator/ffmpegService.js');
+    getAudioInfo = ffmpegService.getAudioInfo;
+    isVideoFile = ffmpegService.isVideoFile;
+
+    const conversionService = await import('../../main/creator/conversionService.js');
+    runConversion = conversionService.runConversion;
+    cancelConversion = conversionService.cancelConversion;
+    isConversionInProgress = conversionService.isConversionInProgress;
+
+    // Import fresh service
+    creatorService = await import('./creatorService.js');
+
+    // Reset conversion state mock
+    isConversionInProgress.mockReturnValue(false);
+  });
+
+  describe('checkComponents', () => {
+    it('should return component status successfully', async () => {
+      checkAllComponents.mockResolvedValue({
+        ffmpeg: { installed: true },
+        python: { installed: true },
+        whisper: { installed: true },
+      });
+
+      const result = await creatorService.checkComponents();
+
+      expect(result.success).toBe(true);
+      expect(result.ffmpeg).toEqual({ installed: true });
+      expect(result.python).toEqual({ installed: true });
+      expect(result.whisper).toEqual({ installed: true });
+    });
+
+    it('should handle check errors', async () => {
+      checkAllComponents.mockRejectedValue(new Error('Check failed'));
+
+      const result = await creatorService.checkComponents();
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Check failed');
+    });
+  });
+
+  describe('getStatus', () => {
+    it('should return installation status', () => {
+      isConversionInProgress.mockReturnValue(false);
+
+      const result = creatorService.getStatus();
+
+      expect(result.installing).toBe(false);
+      expect(result.cancelled).toBe(false);
+      expect(result.converting).toBe(false);
+      expect(result.cacheDir).toBe('/mock/cache/dir');
+      expect(result.pythonPath).toBe('/mock/python');
+    });
+
+    it('should reflect conversion in progress', () => {
+      isConversionInProgress.mockReturnValue(true);
+
+      const result = creatorService.getStatus();
+
+      expect(result.converting).toBe(true);
+    });
+  });
+
+  describe('installComponents', () => {
+    it('should install components successfully', async () => {
+      installAllComponents.mockImplementation((progressCallback) => {
+        progressCallback(50, 'Installing...');
+        progressCallback(100, 'Done');
+        return { success: true };
+      });
+
+      const onProgress = vi.fn();
+      const result = await creatorService.installComponents(onProgress);
+
+      expect(result.success).toBe(true);
+      expect(onProgress).toHaveBeenCalledWith({
+        step: 'starting',
+        message: 'Starting installation...',
+        progress: 0,
+      });
+      expect(onProgress).toHaveBeenCalledWith({
+        step: 'complete',
+        message: 'Installation complete',
+        progress: 100,
+      });
+    });
+
+    it('should handle installation errors', async () => {
+      installAllComponents.mockRejectedValue(new Error('Install failed'));
+
+      const onProgress = vi.fn();
+      const result = await creatorService.installComponents(onProgress);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Install failed');
+    });
+
+    it('should prevent concurrent installations', async () => {
+      // Start first installation (won't resolve)
+      installAllComponents.mockImplementation(() => new Promise(() => {}));
+      creatorService.installComponents(vi.fn());
+
+      // Try to start second
+      const result = await creatorService.installComponents(vi.fn());
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Installation already in progress');
+    });
+  });
+
+  describe('cancelInstall', () => {
+    it('should return error when no installation in progress', () => {
+      const result = creatorService.cancelInstall();
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('No installation in progress');
+    });
+  });
+
+  describe('findLyrics', () => {
+    it('should find lyrics successfully', async () => {
+      searchLyrics.mockResolvedValue({
+        syncedLyrics: '[00:01.00]Hello world',
+        plainLyrics: 'Hello world',
+      });
+
+      const result = await creatorService.findLyrics('Test Song', 'Test Artist');
+
+      expect(result.success).toBe(true);
+      expect(result.syncedLyrics).toBe('[00:01.00]Hello world');
+      expect(result.plainLyrics).toBe('Hello world');
+      expect(searchLyrics).toHaveBeenCalledWith('Test Song', 'Test Artist');
+    });
+
+    it('should return error when no lyrics found', async () => {
+      searchLyrics.mockResolvedValue(null);
+
+      const result = await creatorService.findLyrics('Unknown', 'Unknown');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('No lyrics found');
+    });
+
+    it('should handle search errors', async () => {
+      searchLyrics.mockRejectedValue(new Error('Search failed'));
+
+      const result = await creatorService.findLyrics('Test', 'Test');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Search failed');
+    });
+  });
+
+  describe('getWhisperContext', () => {
+    it('should prepare whisper context successfully', async () => {
+      prepareWhisperContext.mockResolvedValue({
+        vocabulary: ['word1', 'word2'],
+        prompt: 'context prompt',
+      });
+
+      const result = await creatorService.getWhisperContext('Title', 'Artist', 'existing lyrics');
+
+      expect(result.success).toBe(true);
+      expect(result.vocabulary).toEqual(['word1', 'word2']);
+      expect(prepareWhisperContext).toHaveBeenCalledWith('Title', 'Artist', 'existing lyrics');
+    });
+
+    it('should handle context preparation errors', async () => {
+      prepareWhisperContext.mockRejectedValue(new Error('Context failed'));
+
+      const result = await creatorService.getWhisperContext('Title', 'Artist', '');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Context failed');
+    });
+  });
+
+  describe('getFileInfo', () => {
+    it('should return file info with ID3 tags', async () => {
+      getAudioInfo.mockResolvedValue({
+        title: 'Song Title',
+        artist: 'Artist Name',
+        album: 'Album Name',
+        duration: 180,
+        sampleRate: 44100,
+        channels: 2,
+        codec: 'mp3',
+        tags: { year: '2023' },
+      });
+      isVideoFile.mockResolvedValue(false);
+      searchLyrics.mockResolvedValue({
+        syncedLyrics: '[00:01.00]Lyrics',
+      });
+
+      const result = await creatorService.getFileInfo('/path/to/song.mp3');
+
+      expect(result.success).toBe(true);
+      expect(result.file.title).toBe('Song Title');
+      expect(result.file.artist).toBe('Artist Name');
+      expect(result.file.album).toBe('Album Name');
+      expect(result.file.duration).toBe(180);
+      expect(result.file.hasId3Tags).toBe(true);
+      expect(result.file.isVideo).toBe(false);
+      expect(result.lyrics).toBeDefined();
+    });
+
+    it('should parse filename when no ID3 tags', async () => {
+      getAudioInfo.mockResolvedValue({
+        duration: 180,
+        sampleRate: 44100,
+        channels: 2,
+        codec: 'mp3',
+      });
+      isVideoFile.mockResolvedValue(false);
+      searchLyrics.mockResolvedValue(null);
+
+      const result = await creatorService.getFileInfo('/path/to/Artist Name - Song Title.mp3');
+
+      expect(result.success).toBe(true);
+      expect(result.file.title).toBe('Song Title');
+      expect(result.file.artist).toBe('Artist Name');
+      expect(result.file.hasId3Tags).toBe(false);
+    });
+
+    it('should detect video files', async () => {
+      getAudioInfo.mockResolvedValue({ duration: 180 });
+      isVideoFile.mockResolvedValue(true);
+
+      const result = await creatorService.getFileInfo('/path/to/video.mp4');
+
+      expect(result.file.isVideo).toBe(true);
+    });
+
+    it('should handle file info errors', async () => {
+      getAudioInfo.mockRejectedValue(new Error('File not found'));
+
+      const result = await creatorService.getFileInfo('/invalid/path.mp3');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('File not found');
+    });
+
+    it('should continue if lyrics lookup fails', async () => {
+      getAudioInfo.mockResolvedValue({
+        title: 'Song',
+        artist: 'Artist',
+        duration: 180,
+      });
+      isVideoFile.mockResolvedValue(false);
+      searchLyrics.mockRejectedValue(new Error('Network error'));
+
+      const result = await creatorService.getFileInfo('/path/to/song.mp3');
+
+      expect(result.success).toBe(true);
+      expect(result.lyrics).toBeUndefined();
+    });
+  });
+
+  describe('startConversion', () => {
+    it('should start conversion successfully', async () => {
+      runConversion.mockImplementation((options, progressCb) => {
+        progressCb('processing', 'Processing...', 50);
+        return { success: true, outputPath: '/output/file.m4a' };
+      });
+
+      const onProgress = vi.fn();
+      const result = await creatorService.startConversion({ inputPath: '/input.mp3' }, onProgress);
+
+      expect(result.success).toBe(true);
+      expect(result.outputPath).toBe('/output/file.m4a');
+      expect(onProgress).toHaveBeenCalledWith({
+        step: 'starting',
+        message: 'Starting conversion...',
+        progress: 0,
+      });
+    });
+
+    it('should prevent concurrent conversions', async () => {
+      isConversionInProgress.mockReturnValue(true);
+
+      const result = await creatorService.startConversion({}, vi.fn());
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Conversion already in progress');
+    });
+
+    it('should handle conversion errors', async () => {
+      runConversion.mockRejectedValue(new Error('Conversion failed'));
+
+      const result = await creatorService.startConversion({}, vi.fn());
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Conversion failed');
+    });
+
+    it('should pass console output callback', async () => {
+      const onConsoleOutput = vi.fn();
+      runConversion.mockResolvedValue({ success: true });
+
+      await creatorService.startConversion({}, vi.fn(), onConsoleOutput);
+
+      expect(runConversion).toHaveBeenCalledWith({}, expect.any(Function), onConsoleOutput, null);
+    });
+
+    it('should pass settings manager', async () => {
+      const settingsManager = { get: vi.fn() };
+      runConversion.mockResolvedValue({ success: true });
+
+      await creatorService.startConversion({}, vi.fn(), null, settingsManager);
+
+      expect(runConversion).toHaveBeenCalledWith({}, expect.any(Function), null, settingsManager);
+    });
+  });
+
+  describe('stopConversion', () => {
+    it('should stop conversion', () => {
+      cancelConversion.mockReturnValue(true);
+
+      const result = creatorService.stopConversion();
+
+      expect(result.success).toBe(true);
+      expect(cancelConversion).toHaveBeenCalled();
+    });
+
+    it('should return false when cancel fails', () => {
+      cancelConversion.mockReturnValue(false);
+
+      const result = creatorService.stopConversion();
+
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('default export', () => {
+    it('should export all functions', () => {
+      expect(creatorService.default).toBeDefined();
+      expect(creatorService.default.checkComponents).toBeDefined();
+      expect(creatorService.default.getStatus).toBeDefined();
+      expect(creatorService.default.installComponents).toBeDefined();
+      expect(creatorService.default.cancelInstall).toBeDefined();
+      expect(creatorService.default.findLyrics).toBeDefined();
+      expect(creatorService.default.getWhisperContext).toBeDefined();
+      expect(creatorService.default.getFileInfo).toBeDefined();
+      expect(creatorService.default.startConversion).toBeDefined();
+      expect(creatorService.default.stopConversion).toBeDefined();
+    });
+  });
+});

package/src/shared/services/editorService.js

@@ -0,0 +1,213 @@
+/**
+ * Editor Service - Shared business logic for song editing
+ *
+ * Used by both IPC handlers (Electron) and REST endpoints (Web Server)
+ * to ensure consistent song editing behavior across all interfaces.
+ */
+
+import M4ALoader from '../../utils/m4aLoader.js';
+import { Atoms } from 'm4a-stems';
+
+/**
+ * Load a song for editing
+ * @param {string} path - Path to the song file
+ * @returns {Promise<Object>} Song data ready for editing
+ */
+export async function loadSong(path) {
+  if (!path) {
+    throw new Error('Path is required');
+  }
+
+  const lowerPath = path.toLowerCase();
+
+  // M4A/MP4 stems format is the only supported format for editing
+  if (lowerPath.endsWith('.m4a') || lowerPath.endsWith('.mp4')) {
+    const m4aData = await M4ALoader.load(path);
+    m4aData.originalFilePath = path;
+    return {
+      format: 'm4a-stems',
+      kaiData: m4aData, // Named kaiData for compatibility with existing editor components
+    };
+  } else {
+    // CDG and other formats are not supported for editing
+    throw new Error('Only M4A stems format is supported for editing');
+  }
+}
+
+/**
+ * Save song edits
+ * @param {string} path - Path to the song file
+ * @param {Object} updates - Updates to apply
+ * @returns {Promise<Object>} Save result
+ */
+export async function saveSong(path, updates) {
+  if (!path) {
+    throw new Error('Path is required');
+  }
+
+  const { format, metadata, lyrics } = updates;
+
+  if (format === 'm4a-stems') {
+    // Handle M4A format
+    return await saveM4ASong(path, { metadata, lyrics });
+  } else {
+    throw new Error(`Unsupported format: ${format}. Only m4a-stems format is supported.`);
+  }
+}
+
+/**
+ * Save M4A song edits
+ * @param {string} path - Path to M4A file
+ * @param {Object} updates - Updates to apply
+ * @returns {Promise<Object>} Save result
+ */
+async function saveM4ASong(path, updates) {
+  const { metadata, lyrics } = updates;
+
+  // Load existing M4A data
+  const m4aData = await M4ALoader.load(path);
+
+  // Merge metadata updates into the song data
+  const updatedMetadata = { ...m4aData.metadata };
+  if (metadata.title !== undefined) updatedMetadata.title = metadata.title;
+  if (metadata.artist !== undefined) updatedMetadata.artist = metadata.artist;
+  if (metadata.album !== undefined) updatedMetadata.album = metadata.album;
+  if (metadata.year !== undefined) updatedMetadata.year = metadata.year;
+  if (metadata.genre !== undefined) updatedMetadata.genre = metadata.genre;
+  if (metadata.key !== undefined) updatedMetadata.key = metadata.key;
+
+  // NOTE: Standard metadata (title, artist, album, year, genre) is now written
+  // using proper MP4 atoms via addStandardMetadata() below, not FFmpeg
+
+  // Use updated lyrics array
+  let updatedLyrics = m4aData.lyrics;
+  if (lyrics !== undefined && Array.isArray(lyrics)) {
+    updatedLyrics = lyrics;
+  }
+
+  // Prepare data to save
+  const dataToSave = {
+    metadata: updatedMetadata,
+    lyrics: updatedLyrics,
+    audio: m4aData.audio, // Preserve audio configuration
+    features: m4aData.features, // Preserve features
+    singers: m4aData.singers, // Preserve singers
+    meta: m4aData.meta, // Preserve meta
+    tags: m4aData.tags || [], // Preserve existing tags
+  };
+
+  // Add 'edited' tag if not already present
+  if (!dataToSave.tags.includes('edited')) {
+    dataToSave.tags = [...dataToSave.tags, 'edited'];
+  }
+
+  // Handle AI corrections metadata (rejections/suggestions) if present
+  if (metadata.rejections !== undefined || metadata.suggestions !== undefined) {
+    const updatedMeta = { ...(dataToSave.meta || {}) };
+
+    if (!updatedMeta.corrections) {
+      updatedMeta.corrections = {};
+    }
+
+    if (metadata.rejections !== undefined) {
+      updatedMeta.corrections.rejected = metadata.rejections.map((r) => ({
+        line: r.line_num,
+        start: r.start_time,
+        end: r.end_time,
+        old: r.old_text,
+        new: r.new_text,
+        reason: r.reason,
+        word_retention: r.retention_rate,
+      }));
+    }
+
+    if (metadata.suggestions !== undefined) {
+      updatedMeta.corrections.missing_lines_suggested = metadata.suggestions.map((s) => ({
+        suggested_text: s.suggested_text,
+        start: s.start_time,
+        end: s.end_time,
+        confidence: s.confidence,
+        reason: s.reason,
+        pitch_activity: s.pitch_activity,
+      }));
+    }
+
+    dataToSave.meta = updatedMeta;
+  }
+
+  // Prepare kara data structure for m4a-stems
+  // Note: Audio sources are read from the NI Stems 'stem' atom, not stored in kara
+  const karaData = {
+    // Timing information
+    timing: {
+      offset_sec: dataToSave.audio?.timing?.offsetSec || 0,
+      encoder_delay_samples: dataToSave.audio?.timing?.encoderDelaySamples || 0,
+    },
+
+    // Tags for filtering (e.g., 'edited', 'ai_corrected')
+    tags: dataToSave.tags || [],
+
+    // Lyrics (lines) - preserves word-level timing if present
+    lines: (dataToSave.lyrics || []).map((line) => ({
+      start: line.start || line.startTimeSec || 0,
+      end: line.end || line.endTimeSec || 0,
+      text: line.text || '',
+      ...(line.disabled && { disabled: true }),
+      ...(line.singer && { singer: line.singer }),
+      ...(line.words && { words: line.words }),
+    })),
+
+    // Optional: tempo/meter data
+    ...(dataToSave.features?.tempo && {
+      meter: dataToSave.features.tempo,
+    }),
+
+    // Optional: singers
+    ...(dataToSave.singers &&
+      dataToSave.singers.length > 0 && {
+        singers: dataToSave.singers,
+      }),
+
+    // Optional: corrections metadata
+    ...(dataToSave.meta?.corrections && {
+      meta: { corrections: dataToSave.meta.corrections },
+    }),
+  };
+
+  // Save using m4a-stems
+  console.log('💾 Saving M4A kara atom:', path);
+  console.log('📝 kara data prepared:', {
+    lyricsCount: karaData.lines?.length || 0,
+    tagsCount: karaData.tags?.length || 0,
+  });
+
+  await Atoms.writeKaraAtom(path, karaData);
+
+  // Write standard MP4 metadata atoms (title, artist, album, year, genre, BPM)
+  const standardMetadata = {
+    title: updatedMetadata.title,
+    artist: updatedMetadata.artist,
+    album: updatedMetadata.album,
+    year: updatedMetadata.year,
+    genre: updatedMetadata.genre,
+    tempo: updatedMetadata.tempo,
+  };
+  await Atoms.addStandardMetadata(path, standardMetadata);
+
+  // Write musical key if changed (separate atom for DJ software)
+  if (metadata.key !== undefined && updatedMetadata.key) {
+    console.log(`🎹 Writing musical key: ${updatedMetadata.key}`);
+    await Atoms.addMusicalKey(path, updatedMetadata.key);
+  }
+
+  // Restore any preserved atoms that we didn't explicitly handle
+  if (m4aData._preservedAtoms && Object.keys(m4aData._preservedAtoms).length > 0) {
+    console.log(`📦 Restoring ${Object.keys(m4aData._preservedAtoms).length} preserved atoms`);
+    // Note: These atoms are already in the file and we didn't delete them,
+    // so they should still be there. This is just for logging.
+  }
+
+  console.log('✅ M4A file saved successfully');
+
+  return { success: true };
+}