Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

21.0 KB
Raw Blame
jest.mock('expo-file-system/legacy', () => ({
  documentDirectory: 'file:///app/documents/',
  deleteAsync: jest.fn().mockResolvedValue(undefined),
}));
import { eq } from 'drizzle-orm';
import { notes, speakers, transcriptSegments } from '@/db/schema';
import { serializeSegmentsForSync } from '@/lib/notes/remoteTranscript';
import { buildMergeTargetPatch, buildRenameSpeakerPatch } from '@/lib/diarization/speakerEdits';
import type { RemoteNote } from '@/data/types';
import { createMemoryRepository, type TestDb } from './testDb';

const remoteNote = (over: Partial<RemoteNote> = {}): RemoteNote => ({
  id: 'srv-1',
  client_note_id: 'client-1',
  title: 'Sync Meeting',
  content: '',
  enhanced_content: null,
  enhancement_prompt: null,
  note_type: 'meeting',
  source_file: null,
  audio_duration_seconds: null,
  folder_id: null,
  participants: null,
  calendar_event_id: null,
  transcript: null,
  deleted_at: null,
  updated_at: '2026-07-09T10:00:00.000Z',
  ...over,
});
const noFolder = (): number | null => null;

const desktopRaw = JSON.stringify([
  { text: 'Hello everyone.', source: 'mic', timestamp: 1000 },
  {
    text: 'Hi there.',
    source: 'system',
    timestamp: 1500,
    speaker: 'speaker_0',
    speakerName: 'Alice',
    speakerStatus: 'confirmed',
  },
]);

const createMeeting = (db: TestDb, over: Record<string, unknown> = {}) =>
  db
    .insert(notes)
    .values({ title: 'Meeting', content: '', noteType: 'meeting', diarizationEnabled: 1, ...over })
    .returning()
    .get();

describe('LocalNotesRepository.applyRemoteTranscript', () => {
  it('decomposes desktop transcript into segments + speakers with pendingSync=0 and stores the raw', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);

    repo.applyRemoteTranscript(note.id, desktopRaw);

    const seg = repo.getSegments(note.id);
    const spk = repo.getSpeakers(note.id);
    expect(seg).toHaveLength(2);
    expect(spk.map((s) => s.speakerLabel)).toEqual(['__mic__', 'speaker_0']);
    expect(seg.every((s) => s.pendingSync === 0)).toBe(true);
    expect(spk.every((s) => s.pendingSync === 0)).toBe(true);

    const stored = db
      .select({ transcript: notes.transcript })
      .from(notes)
      .where(eq(notes.id, note.id))
      .get();
    expect(stored?.transcript).toBe(desktopRaw);
  });

  it('replaces existing rows on re-apply (no duplicate speakers)', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    repo.applyRemoteTranscript(note.id, desktopRaw);
    repo.applyRemoteTranscript(note.id, desktopRaw);

    expect(repo.getSegments(note.id)).toHaveLength(2);
    expect(repo.getSpeakers(note.id)).toHaveLength(2);
  });

  it('leaves existing rows untouched when the raw is malformed', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    repo.applyRemoteTranscript(note.id, desktopRaw);

    repo.applyRemoteTranscript(note.id, 'not-valid-json');

    // segments preserved; only the raw string is updated for idempotency
    expect(repo.getSegments(note.id)).toHaveLength(2);
    const stored = db
      .select({ transcript: notes.transcript })
      .from(notes)
      .where(eq(notes.id, note.id))
      .get();
    expect(stored?.transcript).toBe('not-valid-json');
  });

  it('preserves device-local speaker profile and color by speaker label', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    db.insert(speakers)
      .values({
        noteId: note.id,
        speakerLabel: 'speaker_0',
        displayName: 'Old remote name',
        profileId: 77,
        color: '#123456',
      })
      .run();

    repo.applyRemoteTranscript(note.id, desktopRaw);

    const alice = repo.getSpeakers(note.id).find((speaker) => speaker.speakerLabel === 'speaker_0');
    expect(alice).toMatchObject({
      displayName: 'Alice',
      profileId: 77,
      color: '#123456',
    });
  });
});

describe('LocalNotesRepository.getPendingNotes transcript discovery', () => {
  it('finds public notes with dirty child rows even when the parent flag is clear', () => {
    const { repo, db } = createMemoryRepository();
    const segmentNote = createMeeting(db, { pendingSync: 0 });
    const speakerNote = createMeeting(db, { pendingSync: 0 });
    db.insert(transcriptSegments)
      .values({
        noteId: segmentNote.id,
        text: 'legacy segment',
        startMs: 0,
        endMs: 1,
        pendingSync: 1,
      })
      .run();
    db.insert(speakers)
      .values({ noteId: speakerNote.id, speakerLabel: 'speaker_0', pendingSync: 1 })
      .run();

    expect(repo.getPendingNotes().map((note) => note.id)).toEqual([segmentNote.id, speakerNote.id]);
  });

  it('does not queue a private note solely because transcript children are dirty', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db, { pendingSync: 0, isPrivate: 1 });
    db.insert(transcriptSegments)
      .values({
        noteId: note.id,
        text: 'private segment',
        startMs: 0,
        endMs: 1,
        pendingSync: 1,
      })
      .run();

    expect(repo.getPendingNotes()).toEqual([]);
  });
});

describe('LocalNotesRepository.hasDirtyTranscript', () => {
  it('is false for a pulled transcript and true after a local segment write', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);

    repo.applyRemoteTranscript(note.id, desktopRaw);
    expect(repo.hasDirtyTranscript(note.id)).toBe(false);

    repo.replaceSegments(note.id, [
      { noteId: note.id, text: 'edited', startMs: 0, endMs: 0, sortOrder: 0 },
    ]);
    expect(repo.hasDirtyTranscript(note.id)).toBe(true);
  });

  it('is true after a local speaker rename', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    repo.applyRemoteTranscript(note.id, desktopRaw);

    const alice = repo.getSpeakers(note.id).find((s) => s.speakerLabel === 'speaker_0')!;
    repo.updateSpeaker(alice.id, { displayName: 'Alice Cooper' });

    expect(repo.hasDirtyTranscript(note.id)).toBe(true);
  });
});

describe('LocalNotesRepository.markTranscriptPushed', () => {
  it('stores the raw and clears pendingSync only for the given row ids', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    repo.replaceSegments(note.id, [
      { noteId: note.id, text: 'a', startMs: 0, endMs: 0, sortOrder: 0 },
      { noteId: note.id, text: 'b', startMs: 0, endMs: 0, sortOrder: 1 },
    ]);
    const seg = repo.getSegments(note.id);
    const raw = serializeSegmentsForSync(seg, repo.getSpeakers(note.id));

    // Only clear the first segment; simulate the second landing after serialization.
    repo.markTranscriptPushed(note.id, raw, [seg[0].id], []);

    const after = db
      .select()
      .from(transcriptSegments)
      .where(eq(transcriptSegments.noteId, note.id))
      .all();
    expect(after.find((s) => s.id === seg[0].id)?.pendingSync).toBe(0);
    expect(after.find((s) => s.id === seg[1].id)?.pendingSync).toBe(1);
    const stored = db
      .select({ transcript: notes.transcript })
      .from(notes)
      .where(eq(notes.id, note.id))
      .get();
    expect(stored?.transcript).toBe(raw);
  });

  it('keeps the transcript and parent dirty when the same speaker changes during the request', () => {
    const { repo, db } = createMemoryRepository();
    repo.applyRemoteNote(remoteNote({ transcript: desktopRaw }), noFolder);
    const [note] = repo.getAllNotes();
    const alice = repo
      .getSpeakers(note.id)
      .find((speaker) => speaker.speakerLabel === 'speaker_0')!;
    const segmentIds = repo.getSegments(note.id).map((segment) => segment.id);
    const speakerIds = repo.getSpeakers(note.id).map((speaker) => speaker.id);
    const pushedRaw = serializeSegmentsForSync(
      repo.getSegments(note.id),
      repo.getSpeakers(note.id),
    );

    // Simulate an edit landing after serialization but before the HTTP response.
    repo.updateSpeaker(alice.id, { displayName: 'Alice Cooper' });
    repo.markNotePushed(repo.getNoteById(note.id)!, 'srv-1', '2026-07-09T11:00:00.000Z');
    repo.markTranscriptPushed(note.id, pushedRaw, segmentIds, speakerIds);

    const afterSpeaker = repo.getSpeakers(note.id).find((speaker) => speaker.id === alice.id);
    const afterNote = db.select().from(notes).where(eq(notes.id, note.id)).get();
    expect(afterSpeaker).toMatchObject({ displayName: 'Alice Cooper', pendingSync: 1 });
    expect(afterNote?.pendingSync).toBe(1);
    expect(repo.getPendingNotes().map((pending) => pending.id)).toContain(note.id);
  });
});

describe('parent-note dirty marking on transcript edits', () => {
  it('marks a shared meeting note pendingSync after replaceSegments', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db, { pendingSync: 0 });
    repo.replaceSegments(note.id, [
      { noteId: note.id, text: 'x', startMs: 0, endMs: 0, sortOrder: 0 },
    ]);

    const row = db
      .select({ pendingSync: notes.pendingSync })
      .from(notes)
      .where(eq(notes.id, note.id))
      .get();
    expect(row?.pendingSync).toBe(1);
  });

  it('marks pendingSync after updateSpeaker and mergeSpeakers', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db, { pendingSync: 0 });
    db.insert(speakers).values({ noteId: note.id, speakerLabel: 'speaker_0', sortOrder: 0 }).run();
    db.insert(speakers).values({ noteId: note.id, speakerLabel: 'speaker_1', sortOrder: 1 }).run();
    const [s0, s1] = repo.getSpeakers(note.id);

    repo.updateSpeaker(s0.id, { displayName: 'Renamed' });
    expect(
      db.select({ p: notes.pendingSync }).from(notes).where(eq(notes.id, note.id)).get()?.p,
    ).toBe(1);

    db.update(notes).set({ pendingSync: 0 }).where(eq(notes.id, note.id)).run();
    repo.mergeSpeakers(note.id, s1.id, s0.id, {});
    expect(
      db.select({ p: notes.pendingSync }).from(notes).where(eq(notes.id, note.id)).get()?.p,
    ).toBe(1);
  });

  it('does NOT mark a private note pendingSync (never syncs)', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db, { pendingSync: 0, isPrivate: 1 });
    repo.replaceSegments(note.id, [
      { noteId: note.id, text: 'x', startMs: 0, endMs: 0, sortOrder: 0 },
    ]);

    const row = db
      .select({ pendingSync: notes.pendingSync })
      .from(notes)
      .where(eq(notes.id, note.id))
      .get();
    expect(row?.pendingSync).toBe(0);
  });
});

describe('applyRemoteNote transcript integration', () => {
  it('builds segments + speakers when inserting a new remote meeting note', () => {
    const { repo } = createMemoryRepository();
    repo.applyRemoteNote(remoteNote({ transcript: desktopRaw }), noFolder);

    const [note] = repo.getAllNotes();
    expect(repo.getSegments(note.id)).toHaveLength(2);
    expect(repo.getSpeakers(note.id).map((s) => s.speakerLabel)).toEqual(['__mic__', 'speaker_0']);
  });

  it('rebuilds segments when an existing note receives a changed transcript', () => {
    const { repo } = createMemoryRepository();
    repo.applyRemoteNote(remoteNote({ transcript: desktopRaw }), noFolder);
    const [note] = repo.getAllNotes();

    const changed = JSON.stringify([{ text: 'Only one line now.', source: 'mic', timestamp: 5 }]);
    repo.applyRemoteNote(
      remoteNote({ transcript: changed, updated_at: '2026-07-09T11:00:00.000Z' }),
      noFolder,
    );

    const seg = repo.getSegments(note.id);
    expect(seg).toHaveLength(1);
    expect(seg[0].text).toBe('Only one line now.');
  });

  it('keeps the recording this device holds when the pull echoes back a null source file', () => {
    const { repo, db } = createMemoryRepository();
    repo.applyRemoteNote(remoteNote({ transcript: desktopRaw }), noFolder);
    const [note] = repo.getAllNotes();
    const recording = `file:///app/documents/meeting-${note.id}.wav`;
    db.update(notes).set({ sourceFile: recording }).where(eq(notes.id, note.id)).run();

    repo.applyRemoteNote(remoteNote({ updated_at: '2026-07-09T11:00:00.000Z' }), noFolder);
    expect(repo.getNoteById(note.id)?.sourceFile).toBe(recording);

    repo.applyRemoteNote(
      remoteNote({
        source_file: 'https://cdn.example/a.wav',
        updated_at: '2026-07-09T12:00:00.000Z',
      }),
      noFolder,
    );
    expect(repo.getNoteById(note.id)?.sourceFile).toBe('https://cdn.example/a.wav');
  });

  it.each([
    ['a file name another device stored', 'file-1.wav'],
    ["a file this device doesn't manage", 'file:///app/documents/imported.wav'],
  ])('clears %s when the pull echoes back a null source file', (_case, sourceFile) => {
    const { repo, db } = createMemoryRepository();
    repo.applyRemoteNote(remoteNote({ transcript: desktopRaw }), noFolder);
    const [note] = repo.getAllNotes();
    db.update(notes).set({ sourceFile }).where(eq(notes.id, note.id)).run();

    repo.applyRemoteNote(remoteNote({ updated_at: '2026-07-09T11:00:00.000Z' }), noFolder);

    expect(repo.getNoteById(note.id)?.sourceFile).toBeNull();
  });

  it('does not rebuild when the transcript is unchanged (segment ids stable)', () => {
    const { repo } = createMemoryRepository();
    repo.applyRemoteNote(remoteNote({ transcript: desktopRaw }), noFolder);
    const [note] = repo.getAllNotes();
    const idsBefore = repo.getSegments(note.id).map((s) => s.id);

    repo.applyRemoteNote(
      remoteNote({ transcript: desktopRaw, updated_at: '2026-07-09T11:00:00.000Z' }),
      noFolder,
    );

    expect(repo.getSegments(note.id).map((s) => s.id)).toEqual(idsBefore);
  });

  it('preserves local segments when the remote transcript is null', () => {
    const { repo } = createMemoryRepository();
    repo.applyRemoteNote(remoteNote({ transcript: desktopRaw }), noFolder);
    const [note] = repo.getAllNotes();

    repo.applyRemoteNote(
      remoteNote({ transcript: null, updated_at: '2026-07-09T11:00:00.000Z' }),
      noFolder,
    );

    expect(repo.getSegments(note.id)).toHaveLength(2);
  });

  it('does not clobber locally-dirty transcript rows on remote change', () => {
    const { repo } = createMemoryRepository();
    repo.applyRemoteNote(remoteNote({ transcript: desktopRaw }), noFolder);
    const [note] = repo.getAllNotes();

    // Local edit makes the note transcript-dirty (also marks the note pendingSync).
    repo.replaceSegments(note.id, [
      { noteId: note.id, text: 'local edit', startMs: 0, endMs: 0, sortOrder: 0 },
    ]);
    // Clear the note-level flag so applyRemoteNote does not short-circuit on it,
    // isolating the transcript-dirty guard.
    repo.markNotePushed(repo.getNoteById(note.id)!, 'srv-1', '2026-07-09T10:30:00.000Z');

    const changed = JSON.stringify([{ text: 'remote wins?', source: 'mic', timestamp: 5 }]);
    repo.applyRemoteNote(
      remoteNote({ transcript: changed, updated_at: '2026-07-09T12:00:00.000Z' }),
      noFolder,
    );

    const seg = repo.getSegments(note.id);
    expect(seg).toHaveLength(1);
    expect(seg[0].text).toBe('local edit');
  });
});

describe('desktop speaker edits across transcript roundtrips', () => {
  function pushAndPull(
    repo: ReturnType<typeof createMemoryRepository>['repo'],
    noteId: number,
  ): ReturnType<typeof createMemoryRepository> & { raw: string; noteId: number } {
    const segments = repo.getSegments(noteId);
    const speakerRows = repo.getSpeakers(noteId);
    const raw = serializeSegmentsForSync(
      segments,
      speakerRows,
      repo.getNoteById(noteId)?.transcript,
    );
    repo.markTranscriptPushed(
      noteId,
      raw,
      segments.map((segment) => segment.id),
      speakerRows.map((speaker) => speaker.id),
    );
    expect(repo.hasDirtyTranscript(noteId)).toBe(false);
    expect(repo.getNoteById(noteId)?.transcript).toBe(raw);

    const fresh = createMemoryRepository();
    fresh.repo.applyRemoteNote(remoteNote({ transcript: raw }), noFolder);
    const [note] = fresh.repo.getAllNotes();
    return { ...fresh, raw, noteId: note.id };
  }

  it('keeps the destination name when the merged source spoke first', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    const original = [
      {
        text: 'Hello',
        source: 'system',
        timestamp: 1000,
        speaker: 'speaker_0',
        speakerName: 'Alice',
      },
      { text: 'Hi', source: 'system', timestamp: 1500, speaker: 'speaker_1', speakerName: 'Bob' },
    ];
    repo.applyRemoteTranscript(note.id, JSON.stringify(original));
    const [alice, bob] = repo.getSpeakers(note.id);
    repo.mergeSpeakers(note.id, alice.id, bob.id, buildMergeTargetPatch(bob));

    const pulled = pushAndPull(repo, note.id);
    expect(pulled.repo.getSpeakers(pulled.noteId)).toEqual([
      expect.objectContaining({ speakerLabel: 'speaker_1', displayName: 'Bob', speakerLocked: 1 }),
    ]);
    expect(JSON.parse(pulled.raw)).toEqual(
      original.map((item) => ({
        ...item,
        speaker: 'speaker_1',
        speakerName: 'Bob',
        speakerStatus: 'locked',
        speakerLocked: true,
        speakerLockSource: 'user',
      })),
    );
  });

  it.each([null, 'Bob'])('clears obsolete suggestions when merging into %s', (displayName) => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    repo.applyRemoteTranscript(
      note.id,
      JSON.stringify([
        {
          text: 'Suggested speaker',
          source: 'system',
          timestamp: 1000,
          speaker: 'speaker_0',
          suggestedName: 'Alice',
          suggestedProfileId: 23,
          speakerStatus: 'suggested',
          futureMetadata: { confidence: 0.91 },
        },
        { text: 'Destination', source: 'system', speaker: 'speaker_1', speakerName: displayName },
      ]),
    );
    const [source, target] = repo.getSpeakers(note.id);
    repo.mergeSpeakers(note.id, source.id, target.id, buildMergeTargetPatch(target));

    const pulled = pushAndPull(repo, note.id);
    const [merged] = JSON.parse(pulled.raw);
    expect(merged).not.toHaveProperty('suggestedName');
    expect(merged).not.toHaveProperty('suggestedProfileId');
    expect(merged).toMatchObject({
      speaker: 'speaker_1',
      speakerLocked: true,
      timestamp: 1000,
      futureMetadata: { confidence: 0.91 },
    });
    expect(pulled.repo.getSpeakers(pulled.noteId)[0].displayName).toBe(displayName);
  });

  it('keeps attribution when a system speaker is merged into You', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    repo.applyRemoteTranscript(note.id, desktopRaw);
    const [mic, alice] = repo.getSpeakers(note.id);
    repo.mergeSpeakers(note.id, alice.id, mic.id, buildMergeTargetPatch(mic));

    const pulled = pushAndPull(repo, note.id);
    expect(pulled.repo.getSegments(pulled.noteId).map((segment) => segment.speakerLabel)).toEqual([
      '__mic__',
      '__mic__',
    ]);
    expect(pulled.repo.getSpeakers(pulled.noteId)).toEqual([
      expect.objectContaining({ speakerLabel: '__mic__', displayName: 'You' }),
    ]);
    expect(JSON.parse(pulled.raw)[1]).toMatchObject({ source: 'mic', timestamp: 1500 });
    expect(JSON.parse(pulled.raw)[1]).not.toHaveProperty('speaker');
  });

  it('uses system attribution when You is merged into a named speaker', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    repo.applyRemoteTranscript(note.id, desktopRaw);
    const [mic, alice] = repo.getSpeakers(note.id);
    repo.mergeSpeakers(note.id, mic.id, alice.id, buildMergeTargetPatch(alice));

    const pulled = pushAndPull(repo, note.id);
    expect(pulled.repo.getSpeakers(pulled.noteId)).toEqual([
      expect.objectContaining({ speakerLabel: 'speaker_0', displayName: 'Alice' }),
    ]);
    expect(JSON.parse(pulled.raw)[0]).toMatchObject({
      source: 'system',
      speaker: 'speaker_0',
      speakerName: 'Alice',
      timestamp: 1000,
    });
  });

  it('locks every renamed line even when the first line was already locked', () => {
    const { repo, db } = createMemoryRepository();
    const note = createMeeting(db);
    const original = [
      {
        text: 'First',
        source: 'system',
        timestamp: 1000,
        speaker: 'speaker_0',
        speakerName: 'Alice',
        speakerStatus: 'locked',
        speakerLocked: true,
        speakerLockSource: 'user',
      },
      {
        text: 'Second',
        source: 'system',
        timestamp: 1500,
        speaker: 'speaker_0',
        speakerName: 'Alice',
        speakerStatus: 'provisional',
        speakerLocked: false,
        futureMetadata: { confidence: 0.91 },
      },
    ];
    repo.applyRemoteTranscript(note.id, JSON.stringify(original));
    const [alice] = repo.getSpeakers(note.id);
    repo.updateSpeaker(alice.id, buildRenameSpeakerPatch(alice, 'Alicia'));

    const pulled = pushAndPull(repo, note.id);
    expect(JSON.parse(pulled.raw)).toEqual(
      original.map((item) => ({
        ...item,
        speakerName: 'Alicia',
        speakerStatus: 'locked',
        speakerLocked: true,
        speakerLockSource: 'user',
      })),
    );
    expect(pulled.repo.getSpeakers(pulled.noteId)[0]).toMatchObject({
      displayName: 'Alicia',
      speakerLocked: 1,
    });
  });
});