@thunderkiller/video-clipper 1.2.0 → 1.3.1

package/tests/chunkBuilder.test.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildMicroBlocks, buildLLMChunks } from '../src/services/chunkBuilder/index.js';
-import type { TranscriptLine, MicroBlock } from '../src/types/index.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeLine(start: number, duration: number, text: string): TranscriptLine {
-  return { start, duration, text };
-}
-
-function makeBlock(start: number, end: number, text: string): MicroBlock {
-  return { start, end, text };
-}
-
-// ---------------------------------------------------------------------------
-// buildMicroBlocks
-// ---------------------------------------------------------------------------
-
-describe('buildMicroBlocks', () => {
-  it('returns empty array for empty input', () => {
-    expect(buildMicroBlocks([], 15)).toEqual([]);
-  });
-
-  it('groups a single line into one block', () => {
-    const lines = [makeLine(0, 5, 'hello world')];
-    const blocks = buildMicroBlocks(lines, 15);
-    expect(blocks).toHaveLength(1);
-    expect(blocks[0].start).toBe(0);
-    expect(blocks[0].text).toBe('hello world');
-    expect(blocks[0].end).toBe(5); // 0 + 5
-  });
-
-  it('groups lines within the window into one block', () => {
-    const lines = [
-      makeLine(0, 3, 'line one'),
-      makeLine(5, 3, 'line two'),
-      makeLine(10, 3, 'line three'),
-    ];
-    const blocks = buildMicroBlocks(lines, 15);
-    expect(blocks).toHaveLength(1);
-    expect(blocks[0].text).toBe('line one line two line three');
-    expect(blocks[0].start).toBe(0);
-    expect(blocks[0].end).toBe(13); // 10 + 3
-  });
-
-  it('starts a new block when a line falls outside the window', () => {
-    const lines = [
-      makeLine(0, 5, 'block one a'),
-      makeLine(5, 5, 'block one b'),
-      makeLine(15, 5, 'block two a'), // exactly at boundary
-      makeLine(20, 5, 'block two b'),
-    ];
-    const blocks = buildMicroBlocks(lines, 15);
-    expect(blocks).toHaveLength(2);
-    expect(blocks[0].text).toBe('block one a block one b');
-    expect(blocks[1].text).toBe('block two a block two b');
-  });
-
-  it('creates multiple blocks for long transcripts', () => {
-    // 6 lines, each 10s apart → should create 4 blocks with a 15s window
-    const lines = Array.from({ length: 6 }, (_, i) => makeLine(i * 10, 5, `line ${i}`));
-    const blocks = buildMicroBlocks(lines, 15);
-    // line 0 (0s) and line 1 (10s) → block 1 [0–20)
-    // line 2 (20s) and line 3 (30s) → block 2 [20–40)
-    // line 4 (40s) and line 5 (50s) → block 3 [40–55]
-    expect(blocks).toHaveLength(3);
-    expect(blocks[0].start).toBe(0);
-    expect(blocks[1].start).toBe(20);
-    expect(blocks[2].start).toBe(40);
-  });
-
-  it('preserves start time of the first line in each block', () => {
-    const lines = [makeLine(3, 5, 'first'), makeLine(25, 5, 'second')];
-    const blocks = buildMicroBlocks(lines, 15);
-    expect(blocks[0].start).toBe(3);
-    expect(blocks[1].start).toBe(25);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// buildLLMChunks
-// ---------------------------------------------------------------------------
-
-describe('buildLLMChunks', () => {
-  it('returns empty array for empty input', () => {
-    expect(buildLLMChunks([], 120, 20)).toEqual([]);
-  });
-
-  it('returns a single chunk when all blocks fit within one window', () => {
-    const blocks = [
-      makeBlock(0, 30, 'first'),
-      makeBlock(30, 60, 'second'),
-      makeBlock(60, 90, 'third'),
-    ];
-    const chunks = buildLLMChunks(blocks, 120, 20);
-    expect(chunks).toHaveLength(1);
-    expect(chunks[0].start).toBe(0);
-    expect(chunks[0].text).toBe('first second third');
-  });
-
-  it('produces overlapping chunks', () => {
-    // 12 blocks of 10s each → 120s total
-    // chunkLen=60, overlap=20 → step=40
-    // chunk 1: blocks starting 0–59s → [0,10,20,30,40,50]
-    // chunk 2: blocks starting 40–99s → [40,50,60,70,80,90]
-    // chunk 3: blocks starting 80–139s (capped at 120) → [80,90,100,110]
-    const blocks = Array.from({ length: 12 }, (_, i) => makeBlock(i * 10, i * 10 + 10, `b${i}`));
-    const chunks = buildLLMChunks(blocks, 60, 20);
-    expect(chunks).toHaveLength(3);
-
-    // Chunk 1: blocks 0–50
-    expect(chunks[0].start).toBe(0);
-    expect(chunks[0].text).toContain('b0');
-    expect(chunks[0].text).toContain('b5');
-
-    // Chunk 2 starts at 40 (step = 40 from 0)
-    expect(chunks[1].start).toBe(40);
-    expect(chunks[1].text).toContain('b4');
-    expect(chunks[1].text).toContain('b9');
-
-    // Overlap: b4 and b5 appear in both chunk 1 and chunk 2
-    expect(chunks[0].text).toContain('b4');
-    expect(chunks[1].text).toContain('b4');
-  });
-
-  it('does not produce empty chunks', () => {
-    const blocks = [makeBlock(0, 10, 'only')];
-    const chunks = buildLLMChunks(blocks, 120, 20);
-    expect(chunks).toHaveLength(1);
-    expect(chunks[0].text).toBe('only');
-  });
-
-  it('chunk start is the start of the first included block', () => {
-    const blocks = [makeBlock(5, 15, 'a'), makeBlock(15, 25, 'b')];
-    const chunks = buildLLMChunks(blocks, 120, 20);
-    expect(chunks[0].start).toBe(5);
-  });
-
-  it('chunk end is the end of the last included block', () => {
-    const blocks = [makeBlock(0, 60, 'a'), makeBlock(60, 90, 'b')];
-    const chunks = buildLLMChunks(blocks, 120, 20);
-    expect(chunks[0].end).toBe(90);
-  });
-});

package/tests/chunker.test.ts

@@ -1,95 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildWindows } from '../src/utils/chunker.js';
-
-describe('buildWindows', () => {
-  it('returns empty array when totalDuration is 0', () => {
-    expect(buildWindows(0, 30)).toEqual([]);
-  });
-
-  it('returns empty array when totalDuration is negative', () => {
-    expect(buildWindows(-10, 30)).toEqual([]);
-  });
-
-  it('returns empty array when windowSec is 0', () => {
-    expect(buildWindows(60, 0)).toEqual([]);
-  });
-
-  it('returns empty array when windowSec is negative', () => {
-    expect(buildWindows(60, -5)).toEqual([]);
-  });
-
-  it('produces non-overlapping equal windows with no overlap', () => {
-    const windows = buildWindows(60, 20);
-    expect(windows).toEqual([
-      { start: 0, end: 20 },
-      { start: 20, end: 40 },
-      { start: 40, end: 60 },
-    ]);
-  });
-
-  it('clips the last window end to totalDuration', () => {
-    const windows = buildWindows(70, 30);
-    expect(windows).toEqual([
-      { start: 0, end: 30 },
-      { start: 30, end: 60 },
-      { start: 60, end: 70 },
-    ]);
-  });
-
-  it('handles exact-fit duration (no remainder)', () => {
-    const windows = buildWindows(90, 30);
-    expect(windows).toHaveLength(3);
-    expect(windows[2]).toEqual({ start: 60, end: 90 });
-  });
-
-  it('produces overlapping windows when overlapSec > 0', () => {
-    const windows = buildWindows(60, 30, 10);
-    // step = 30 - 10 = 20
-    expect(windows).toEqual([
-      { start: 0, end: 30 },
-      { start: 20, end: 50 },
-      { start: 40, end: 60 },
-    ]);
-  });
-
-  it('first window starts at 0', () => {
-    const windows = buildWindows(100, 25);
-    expect(windows[0].start).toBe(0);
-  });
-
-  it('last window end does not exceed totalDuration', () => {
-    for (const [dur, win, ov] of [
-      [100, 30, 0],
-      [100, 30, 10],
-      [77, 20, 5],
-    ] as [number, number, number][]) {
-      const ws = buildWindows(dur, win, ov);
-      for (const w of ws) {
-        expect(w.end).toBeLessThanOrEqual(dur);
-      }
-    }
-  });
-
-  it('all windows have positive width', () => {
-    const windows = buildWindows(55, 20, 5);
-    for (const w of windows) {
-      expect(w.end).toBeGreaterThan(w.start);
-    }
-  });
-
-  it('treats negative overlapSec as 0', () => {
-    const withNeg = buildWindows(60, 20, -10);
-    const withZero = buildWindows(60, 20, 0);
-    expect(withNeg).toEqual(withZero);
-  });
-
-  it('treats overlapSec >= windowSec as 0 (avoids infinite loop)', () => {
-    const windows = buildWindows(60, 20, 20);
-    expect(windows).toEqual(buildWindows(60, 20, 0));
-  });
-
-  it('handles a single-window case (duration <= windowSec)', () => {
-    const windows = buildWindows(15, 30);
-    expect(windows).toEqual([{ start: 0, end: 15 }]);
-  });
-});

package/tests/eventDetector.test.ts

@@ -1,103 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { EventDetector } from '../src/services/eventDetector/index.js';
-import type { AudioAnalyzer } from '../src/services/audioAnalyzers/index.js';
-import type { AudioEvent } from '../src/types/index.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeAnalyzer(source: AudioEvent['source'], result: AudioEvent[] | Error): AudioAnalyzer {
-  return {
-    source,
-    detect: vi
-      .fn()
-      .mockImplementation(() =>
-        result instanceof Error ? Promise.reject(result) : Promise.resolve(result),
-      ),
-  } as unknown as AudioAnalyzer;
-}
-
-const EVENT_A: AudioEvent = { time: 10, event: 'gunshot', confidence: 0.9, source: 'gemini' };
-const EVENT_B: AudioEvent = { time: 20, event: 'explosion', confidence: 0.8, source: 'whisper' };
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('EventDetector', () => {
-  describe('constructor', () => {
-    it('throws when chain is empty', () => {
-      expect(() => new EventDetector([])).toThrow(
-        'EventDetector requires at least one AudioAnalyzer',
-      );
-    });
-  });
-
-  describe('detect — single analyzer', () => {
-    it('returns events from the sole analyzer on success', async () => {
-      const analyzer = makeAnalyzer('gemini', [EVENT_A]);
-      const detector = new EventDetector([analyzer]);
-      const events = await detector.detect('audio.wav', 'general', 0, 120);
-      expect(events).toEqual([EVENT_A]);
-      expect(analyzer.detect).toHaveBeenCalledOnce();
-    });
-
-    it('re-throws when the sole analyzer fails', async () => {
-      const err = new Error('gemini unavailable');
-      const analyzer = makeAnalyzer('gemini', err);
-      const detector = new EventDetector([analyzer]);
-      await expect(detector.detect('audio.wav', 'general', 0, 120)).rejects.toThrow(
-        'gemini unavailable',
-      );
-    });
-  });
-
-  describe('detect — fallback chain', () => {
-    it('returns first-analyzer result without trying the second', async () => {
-      const first = makeAnalyzer('gemini', [EVENT_A]);
-      const second = makeAnalyzer('whisper', [EVENT_B]);
-      const detector = new EventDetector([first, second]);
-      const events = await detector.detect('audio.wav', 'general', 0, 120);
-      expect(events).toEqual([EVENT_A]);
-      expect(second.detect).not.toHaveBeenCalled();
-    });
-
-    it('falls back to second analyzer when first throws', async () => {
-      const first = makeAnalyzer('gemini', new Error('timeout'));
-      const second = makeAnalyzer('whisper', [EVENT_B]);
-      const detector = new EventDetector([first, second]);
-      const events = await detector.detect('audio.wav', 'general', 0, 120);
-      expect(events).toEqual([EVENT_B]);
-    });
-
-    it('re-throws the last error when the entire chain is exhausted', async () => {
-      const err1 = new Error('gemini down');
-      const err2 = new Error('whisper crashed');
-      const first = makeAnalyzer('gemini', err1);
-      const second = makeAnalyzer('whisper', err2);
-      const detector = new EventDetector([first, second]);
-      await expect(detector.detect('audio.wav', 'general', 0, 120)).rejects.toThrow(
-        'whisper crashed',
-      );
-    });
-
-    it('skips failing analyzers and returns results from a later one in a three-item chain', async () => {
-      const first = makeAnalyzer('gemini', new Error('fail'));
-      const second = makeAnalyzer('whisper', new Error('fail'));
-      const third = makeAnalyzer('yamnet', [EVENT_A, EVENT_B]);
-      const detector = new EventDetector([first, second, third]);
-      const events = await detector.detect('audio.wav', 'fps', 0, 120);
-      expect(events).toHaveLength(2);
-    });
-  });
-
-  describe('detect — argument forwarding', () => {
-    it('passes all arguments through to the analyzer', async () => {
-      const analyzer = makeAnalyzer('gemini', []);
-      const detector = new EventDetector([analyzer]);
-      await detector.detect('/tmp/slice.wav', 'valorant', 60, 120);
-      expect(analyzer.detect).toHaveBeenCalledWith('/tmp/slice.wav', 'valorant', 60, 120);
-    });
-  });
-});

package/tests/llmAnalyzer.test.ts

@@ -1,283 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { LLMAnalyzer } from '../src/services/llmAnalyzer/LLMAnalyzer.js';
-import type { TranscriptDetector } from '../src/services/transcriptDetector/index.js';
-import type { Cache } from '../src/utils/cache.js';
-import type {
-  TranscriptLine,
-  MicroBlock,
-  LLMChunk,
-  ChunkEvaluation,
-  RankedSegment,
-} from '../src/types/index.js';
-
-// ---------------------------------------------------------------------------
-// Module mocks — must be declared before any imports that touch these modules
-// ---------------------------------------------------------------------------
-
-vi.mock('../src/services/llmAnalyzer/index.js', () => ({
-  analyzeChunks: vi.fn(),
-}));
-
-vi.mock('../src/services/clipRefiner/index.js', () => ({
-  refineSegments: vi.fn(),
-}));
-
-// Import the mocked free functions so we can configure them per test
-import { analyzeChunks } from '../src/services/llmAnalyzer/index.js';
-import { refineSegments } from '../src/services/clipRefiner/index.js';
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-const LINES: TranscriptLine[] = [
-  { text: 'Hello world', start: 0, duration: 2 },
-  { text: 'Second line', start: 2, duration: 2 },
-];
-
-const MICRO_BLOCKS: MicroBlock[] = [{ text: 'Hello world Second line', start: 0, end: 15 }];
-
-const CHUNKS: LLMChunk[] = [{ text: 'Hello world Second line', start: 0, end: 120 }];
-
-const SUCCESS_EVAL: ChunkEvaluation = {
-  status: 'success',
-  chunk_index: 0,
-  chunk_start: 0,
-  chunk_end: 120,
-  interesting: true,
-  score: 8,
-  reason: 'great moment',
-  clip_start: 10,
-  clip_end: 60,
-};
-
-const RANKED_SEGMENT: RankedSegment = {
-  start: 10,
-  end: 60,
-  score: 8,
-  rank: 1,
-  reason: 'great moment',
-  source: 'transcript',
-};
-
-// ---------------------------------------------------------------------------
-// Stub builders
-// ---------------------------------------------------------------------------
-
-function makeTranscriptDetector(
-  result: { lines: TranscriptLine[]; microBlocks: MicroBlock[]; chunks: LLMChunk[] } | Error,
-): TranscriptDetector {
-  return {
-    detect: vi
-      .fn()
-      .mockImplementation(() =>
-        result instanceof Error ? Promise.reject(result) : Promise.resolve(result),
-      ),
-  } as unknown as TranscriptDetector;
-}
-
-function makeCache(): Cache {
-  return {} as unknown as Cache;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('LLMAnalyzer', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  // ── analyze() ─────────────────────────────────────────────────────────────
-
-  describe('analyze()', () => {
-    it('returns lines, microBlocks, chunks, and chunkEvals on success', async () => {
-      const detector = makeTranscriptDetector({
-        lines: LINES,
-        microBlocks: MICRO_BLOCKS,
-        chunks: CHUNKS,
-      });
-      vi.mocked(analyzeChunks).mockResolvedValue([SUCCESS_EVAL]);
-
-      const analyzer = new LLMAnalyzer(detector, makeCache());
-      const result = await analyzer.analyze({
-        videoId: 'abc123',
-        audioPath: null,
-        audioEvents: [],
-        maxParallel: 3,
-        noCache: true,
-      });
-
-      expect(result.lines).toEqual(LINES);
-      expect(result.microBlocks).toEqual(MICRO_BLOCKS);
-      expect(result.chunks).toEqual(CHUNKS);
-      expect(result.chunkEvals).toEqual([SUCCESS_EVAL]);
-    });
-
-    it('passes videoId, audioPath, and cache to transcriptDetector.detect', async () => {
-      const detector = makeTranscriptDetector({
-        lines: LINES,
-        microBlocks: MICRO_BLOCKS,
-        chunks: CHUNKS,
-      });
-      const cache = makeCache();
-      vi.mocked(analyzeChunks).mockResolvedValue([SUCCESS_EVAL]);
-
-      const analyzer = new LLMAnalyzer(detector, cache);
-      await analyzer.analyze({
-        videoId: 'vid-xyz',
-        audioPath: '/tmp/audio.wav',
-        audioEvents: [],
-        maxParallel: 2,
-        noCache: false,
-      });
-
-      expect(detector.detect).toHaveBeenCalledWith('vid-xyz', '/tmp/audio.wav', cache);
-    });
-
-    it('forwards audioEvents and noCache to analyzeChunks', async () => {
-      const audioEvents = [
-        { time: 5, event: 'explosion', confidence: 0.9, source: 'gemini' as const },
-      ];
-      const detector = makeTranscriptDetector({
-        lines: LINES,
-        microBlocks: MICRO_BLOCKS,
-        chunks: CHUNKS,
-      });
-      vi.mocked(analyzeChunks).mockResolvedValue([SUCCESS_EVAL]);
-
-      const analyzer = new LLMAnalyzer(detector, makeCache());
-      await analyzer.analyze({
-        videoId: 'abc123',
-        audioPath: null,
-        audioEvents,
-        maxParallel: 1,
-        noCache: true,
-      });
-
-      expect(analyzeChunks).toHaveBeenCalledWith(
-        CHUNKS,
-        LINES,
-        audioEvents,
-        1, // maxParallel
-        true, // noCache
-      );
-    });
-
-    it('limits chunks to maxChunks when provided', async () => {
-      const manyChunks: LLMChunk[] = Array.from({ length: 5 }, (_, i) => ({
-        text: `chunk ${i}`,
-        start: i * 120,
-        end: (i + 1) * 120,
-      }));
-      const detector = makeTranscriptDetector({
-        lines: LINES,
-        microBlocks: MICRO_BLOCKS,
-        chunks: manyChunks,
-      });
-      vi.mocked(analyzeChunks).mockResolvedValue([SUCCESS_EVAL]);
-
-      const analyzer = new LLMAnalyzer(detector, makeCache());
-      await analyzer.analyze({
-        videoId: 'abc123',
-        audioPath: null,
-        audioEvents: [],
-        maxChunks: 2,
-        maxParallel: 3,
-        noCache: true,
-      });
-
-      const calledWith = vi.mocked(analyzeChunks).mock.calls[0][0] as LLMChunk[];
-      expect(calledWith).toHaveLength(2);
-    });
-
-    it('throws when all chunks fail (zero succeeded)', async () => {
-      const failedEval: ChunkEvaluation = {
-        status: 'failed',
-        chunk_index: 0,
-        chunk_start: 0,
-        chunk_end: 120,
-        error: 'LLM error',
-      };
-      const detector = makeTranscriptDetector({
-        lines: LINES,
-        microBlocks: MICRO_BLOCKS,
-        chunks: CHUNKS,
-      });
-      vi.mocked(analyzeChunks).mockResolvedValue([failedEval]);
-
-      const analyzer = new LLMAnalyzer(detector, makeCache());
-
-      await expect(
-        analyzer.analyze({
-          videoId: 'abc123',
-          audioPath: null,
-          audioEvents: [],
-          maxParallel: 1,
-          noCache: true,
-        }),
-      ).rejects.toThrow('All chunks failed LLM analysis');
-    });
-
-    it('propagates errors thrown by transcriptDetector.detect', async () => {
-      const detector = makeTranscriptDetector(new Error('no transcript available'));
-
-      const analyzer = new LLMAnalyzer(detector, makeCache());
-
-      await expect(
-        analyzer.analyze({
-          videoId: 'abc123',
-          audioPath: null,
-          audioEvents: [],
-          maxParallel: 1,
-          noCache: true,
-        }),
-      ).rejects.toThrow('no transcript available');
-    });
-  });
-
-  // ── refine() ──────────────────────────────────────────────────────────────
-
-  describe('refine()', () => {
-    it('delegates to refineSegments and returns its result', async () => {
-      const refined: RankedSegment = { ...RANKED_SEGMENT, start: 12, end: 58 };
-      vi.mocked(refineSegments).mockResolvedValue([refined]);
-
-      const analyzer = new LLMAnalyzer(
-        makeTranscriptDetector({ lines: LINES, microBlocks: MICRO_BLOCKS, chunks: CHUNKS }),
-        makeCache(),
-      );
-      const result = await analyzer.refine([RANKED_SEGMENT], MICRO_BLOCKS, {
-        maxParallel: 2,
-        noCache: false,
-      });
-
-      expect(result).toEqual([refined]);
-    });
-
-    it('passes segments, microBlocks, maxParallel and noCache to refineSegments', async () => {
-      vi.mocked(refineSegments).mockResolvedValue([RANKED_SEGMENT]);
-
-      const analyzer = new LLMAnalyzer(
-        makeTranscriptDetector({ lines: LINES, microBlocks: MICRO_BLOCKS, chunks: CHUNKS }),
-        makeCache(),
-      );
-      await analyzer.refine([RANKED_SEGMENT], MICRO_BLOCKS, { maxParallel: 4, noCache: true });
-
-      expect(refineSegments).toHaveBeenCalledWith([RANKED_SEGMENT], MICRO_BLOCKS, 4, true);
-    });
-
-    it('returns an empty array when passed no segments', async () => {
-      vi.mocked(refineSegments).mockResolvedValue([]);
-
-      const analyzer = new LLMAnalyzer(
-        makeTranscriptDetector({ lines: LINES, microBlocks: MICRO_BLOCKS, chunks: CHUNKS }),
-        makeCache(),
-      );
-      const result = await analyzer.refine([], MICRO_BLOCKS, { maxParallel: 1, noCache: true });
-
-      expect(result).toEqual([]);
-    });
-  });
-});