@thunderkiller/video-clipper 1.2.0 → 1.3.1

package/src/utils/logger.ts

@@ -1,17 +0,0 @@
-const LEVELS = {
-  info: '[info]',
-  warn: '[warn]',
-  error: '[error]',
-} as const;
-
-export const log = {
-  info: (msg: string): void => {
-    console.log(`${LEVELS.info} ${msg}`);
-  },
-  warn: (msg: string): void => {
-    console.warn(`${LEVELS.warn} ${msg}`);
-  },
-  error: (msg: string): void => {
-    console.error(`${LEVELS.error} ${msg}`);
-  },
-};

package/src/utils/modelFactory.ts

@@ -1,71 +0,0 @@
-import { createOpenAI, openai } from '@ai-sdk/openai';
-import { anthropic } from '@ai-sdk/anthropic';
-import { google } from '@ai-sdk/google';
-import { xai } from '@ai-sdk/xai';
-import { mistral } from '@ai-sdk/mistral';
-import { groq } from '@ai-sdk/groq';
-import type { LanguageModel } from 'ai';
-import { config } from '../config/index.js';
-import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
-
-/**
- * Returns a Vercel AI SDK LanguageModel instance for the configured provider
- * and model. Both `llmAnalyzer` and `clipRefiner` call this instead of
- * hard-coding `openai(config.LLM_MODEL)`.
- *
- * The active provider is controlled by `LLM_PROVIDER` in the environment.
- * The model name is controlled by `LLM_MODEL`.
- *
- * In ai@5, all provider packages ship LanguageModelV3 which natively
- * satisfies the LanguageModel interface.
- */
-export function getModel(): LanguageModel {
-  const model = config.LLM_MODEL;
-
-  switch (config.LLM_PROVIDER) {
-    case 'openai':
-      return openai.languageModel(model);
-
-    case 'anthropic':
-      return anthropic.languageModel(model);
-
-    case 'google':
-      return google.languageModel(model);
-
-    case 'xai':
-      return xai.languageModel(model);
-
-    case 'mistral':
-      return mistral.languageModel(model);
-
-    case 'groq':
-      return groq.languageModel(model);
-
-    case 'zai':
-      return createOpenAICompatible({
-        name: 'zai',
-        baseURL: 'https://api.z.ai/api/paas/v4',
-        apiKey: config.ZAI_API_KEY,
-        // Zai is OpenAI-compatible and supports json_schema response format.
-        // Without this flag the SDK falls back to json_object mode and emits
-        // a "responseFormat not supported" warning on every chunk call.
-        supportsStructuredOutputs: true,
-      }).languageModel(model);
-
-    case 'openrouter':
-      return createOpenAI({
-        baseURL: 'https://openrouter.ai/api/v1',
-        apiKey: config.OPENROUTER_API_KEY,
-      }).languageModel(model);
-
-    case 'custom':
-      return createOpenAICompatible({
-        name: 'custom',
-        baseURL: config.CUSTOM_OPENAI_BASE_URL!,
-        apiKey: config.CUSTOM_OPENAI_API_KEY,
-        // Treat as a fully OpenAI-compatible endpoint with structured output
-        // support so generateObject uses json_schema mode, not json_object fallback.
-        supportsStructuredOutputs: true,
-      }).languageModel(model);
-  }
-}

package/src/utils/redactConfig.ts

@@ -1,23 +0,0 @@
-import type { Config } from '../types/config.js';
-
-const SENSITIVE_KEYS = new Set([
-  'OPENAI_API_KEY',
-  'ANTHROPIC_API_KEY',
-  'GOOGLE_GENERATIVE_AI_API_KEY',
-  'XAI_API_KEY',
-  'MISTRAL_API_KEY',
-  'GROQ_API_KEY',
-  'ZAI_API_KEY',
-]);
-
-/**
- * Formats the resolved config as a single-line key=value string,
- * omitting all API key fields and any undefined optional values.
- */
-export function formatConfig(cfg: Config): string {
-  return (Object.entries(cfg) as [string, unknown][])
-    .filter(([k]) => !SENSITIVE_KEYS.has(k))
-    .filter(([, v]) => v !== undefined)
-    .map(([k, v]) => `${k}=${String(v)}`)
-    .join(' ');
-}

package/src/utils/sliceAudio.ts

@@ -1,35 +0,0 @@
-import * as path from 'path';
-import ffmpeg from 'fluent-ffmpeg';
-import { config } from '../config/index.js';
-
-if (config.FFMPEG_PATH) {
-  ffmpeg.setFfmpegPath(config.FFMPEG_PATH);
-}
-if (config.FFPROBE_PATH) {
-  ffmpeg.setFfprobePath(config.FFPROBE_PATH);
-}
-
-export async function sliceAudio(
-  inputPath: string,
-  startSec: number,
-  durationSec: number,
-  outputDir: string,
-): Promise<string> {
-  const filename = path.basename(inputPath, path.extname(inputPath));
-  const outputPath = path.join(outputDir, `${filename}_slice_${startSec}.wav`);
-
-  await new Promise<void>((resolve, reject) => {
-    ffmpeg(inputPath)
-      .setStartTime(startSec)
-      .setDuration(durationSec)
-      .audioFrequency(16000)
-      .audioChannels(1)
-      .format('wav')
-      .output(outputPath)
-      .on('end', () => resolve())
-      .on('error', (err) => reject(err))
-      .run();
-  });
-
-  return outputPath;
-}

package/test-trigger.txt

@@ -1 +0,0 @@
-test trigger for release workflow

package/tests/analyzerFactory.test.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseProviderChain, createAnalyzerChain } from '../src/services/audioAnalyzers/index.js';
-import {
-  parseTranscriptProviderChain,
-  createTranscriptChain,
-} from '../src/services/transcriptAnalyzers/index.js';
-import { GeminiAudioAnalyzer } from '../src/services/audioAnalyzers/gemini.js';
-import { WhisperAudioAnalyzer } from '../src/services/audioAnalyzers/whisper.js';
-import { YAMNetAudioAnalyzer } from '../src/services/audioAnalyzers/yamnet.js';
-import { YtDlpTranscriptAnalyzer } from '../src/services/transcriptAnalyzers/ytdlp.js';
-import { WhisperTranscriptAnalyzer } from '../src/services/transcriptAnalyzers/whisper.js';
-import { GeminiTranscriptAnalyzer } from '../src/services/transcriptAnalyzers/gemini.js';
-
-// ---------------------------------------------------------------------------
-// Audio analyzer factory
-// ---------------------------------------------------------------------------
-
-describe('parseProviderChain (audio)', () => {
-  it('parses a single provider', () => {
-    expect(parseProviderChain('gemini')).toEqual(['gemini']);
-  });
-
-  it('parses a comma-separated chain', () => {
-    expect(parseProviderChain('gemini,whisper')).toEqual(['gemini', 'whisper']);
-  });
-
-  it('parses all three providers', () => {
-    expect(parseProviderChain('gemini,whisper,yamnet')).toEqual(['gemini', 'whisper', 'yamnet']);
-  });
-
-  it('trims whitespace around provider names', () => {
-    expect(parseProviderChain(' gemini , whisper ')).toEqual(['gemini', 'whisper']);
-  });
-
-  it('maps legacy "both" to ["gemini", "whisper"]', () => {
-    expect(parseProviderChain('both')).toEqual(['gemini', 'whisper']);
-  });
-
-  it('throws on an unknown provider name', () => {
-    expect(() => parseProviderChain('openai')).toThrow('Unknown audio provider "openai"');
-  });
-
-  it('throws when the string is empty', () => {
-    expect(() => parseProviderChain('')).toThrow('AUDIO_PROVIDER is empty');
-  });
-
-  it('throws when a chain contains one unknown name', () => {
-    expect(() => parseProviderChain('gemini,unknown')).toThrow('Unknown audio provider "unknown"');
-  });
-});
-
-describe('createAnalyzerChain (audio)', () => {
-  it('returns a GeminiAudioAnalyzer for "gemini"', () => {
-    const chain = createAnalyzerChain('gemini');
-    expect(chain).toHaveLength(1);
-    expect(chain[0]).toBeInstanceOf(GeminiAudioAnalyzer);
-  });
-
-  it('returns a WhisperAudioAnalyzer for "whisper"', () => {
-    const chain = createAnalyzerChain('whisper');
-    expect(chain[0]).toBeInstanceOf(WhisperAudioAnalyzer);
-  });
-
-  it('returns a YAMNetAudioAnalyzer for "yamnet"', () => {
-    const chain = createAnalyzerChain('yamnet');
-    expect(chain[0]).toBeInstanceOf(YAMNetAudioAnalyzer);
-  });
-
-  it('returns analyzers in the declared order for a two-item chain', () => {
-    const chain = createAnalyzerChain('gemini,whisper');
-    expect(chain).toHaveLength(2);
-    expect(chain[0]).toBeInstanceOf(GeminiAudioAnalyzer);
-    expect(chain[1]).toBeInstanceOf(WhisperAudioAnalyzer);
-  });
-
-  it('maps legacy "both" to [Gemini, Whisper]', () => {
-    const chain = createAnalyzerChain('both');
-    expect(chain).toHaveLength(2);
-    expect(chain[0]).toBeInstanceOf(GeminiAudioAnalyzer);
-    expect(chain[1]).toBeInstanceOf(WhisperAudioAnalyzer);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Transcript analyzer factory
-// ---------------------------------------------------------------------------
-
-describe('parseTranscriptProviderChain', () => {
-  it('parses a single provider', () => {
-    expect(parseTranscriptProviderChain('ytdlp')).toEqual(['ytdlp']);
-  });
-
-  it('parses a comma-separated chain', () => {
-    expect(parseTranscriptProviderChain('ytdlp,whisper')).toEqual(['ytdlp', 'whisper']);
-  });
-
-  it('trims whitespace around provider names', () => {
-    expect(parseTranscriptProviderChain(' ytdlp , whisper ')).toEqual(['ytdlp', 'whisper']);
-  });
-
-  it('throws on an unknown provider name', () => {
-    expect(() => parseTranscriptProviderChain('openai')).toThrow(
-      'Unknown transcript provider "openai"',
-    );
-  });
-
-  it('throws when the string is empty', () => {
-    expect(() => parseTranscriptProviderChain('')).toThrow('TRANSCRIPT_PROVIDER is empty');
-  });
-
-  it('throws when a chain contains one unknown name', () => {
-    expect(() => parseTranscriptProviderChain('ytdlp,unknown')).toThrow(
-      'Unknown transcript provider "unknown"',
-    );
-  });
-});
-
-describe('createTranscriptChain', () => {
-  it('returns a YtDlpTranscriptAnalyzer for "ytdlp"', () => {
-    const chain = createTranscriptChain('ytdlp');
-    expect(chain).toHaveLength(1);
-    expect(chain[0]).toBeInstanceOf(YtDlpTranscriptAnalyzer);
-  });
-
-  it('returns a WhisperTranscriptAnalyzer for "whisper"', () => {
-    const chain = createTranscriptChain('whisper');
-    expect(chain[0]).toBeInstanceOf(WhisperTranscriptAnalyzer);
-  });
-
-  it('returns a GeminiTranscriptAnalyzer for "gemini"', () => {
-    const chain = createTranscriptChain('gemini');
-    expect(chain[0]).toBeInstanceOf(GeminiTranscriptAnalyzer);
-  });
-
-  it('returns analyzers in the declared order for a two-item chain', () => {
-    const chain = createTranscriptChain('ytdlp,whisper');
-    expect(chain).toHaveLength(2);
-    expect(chain[0]).toBeInstanceOf(YtDlpTranscriptAnalyzer);
-    expect(chain[1]).toBeInstanceOf(WhisperTranscriptAnalyzer);
-  });
-
-  it('GeminiTranscriptAnalyzer throws when detect() is called (stub)', async () => {
-    const chain = createTranscriptChain('gemini');
-    await expect(chain[0].detect('abc', null)).rejects.toThrow('not yet implemented');
-  });
-});

package/tests/audioEventDetector.test.ts

@@ -1,69 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { normalizeGeminiTime } from '../src/services/audioAnalyzers/gemini.js';
-
-const CHUNK = 120; // default chunk duration in seconds
-
-describe('normalizeGeminiTime', () => {
-  // --- MM.SS format (frac ≤ 0.59, MM.SS result within chunk) ---
-
-  it('converts 0.41 (MM.SS: 0min 41sec) to 41', () => {
-    expect(normalizeGeminiTime(0.41, CHUNK)).toBe(41);
-  });
-
-  it('converts 0.55 (MM.SS: 0min 55sec) to 55', () => {
-    expect(normalizeGeminiTime(0.55, CHUNK)).toBe(55);
-  });
-
-  it('converts 1.03 (MM.SS: 1min 3sec) to 63', () => {
-    expect(normalizeGeminiTime(1.03, CHUNK)).toBe(63);
-  });
-
-  it('converts 1.40 (MM.SS: 1min 40sec) to 100', () => {
-    expect(normalizeGeminiTime(1.4, CHUNK)).toBe(100);
-  });
-
-  it('converts 1.59 (MM.SS: 1min 59sec) to 119', () => {
-    expect(normalizeGeminiTime(1.59, CHUNK)).toBe(119);
-  });
-
-  it('converts 0.00 to 0', () => {
-    expect(normalizeGeminiTime(0.0, CHUNK)).toBe(0);
-  });
-
-  // --- True decimal seconds (frac > 0.59 → cannot be MM.SS) ---
-
-  it('treats 53.403 as true decimal seconds (frac > 0.59)', () => {
-    expect(normalizeGeminiTime(53.403, CHUNK)).toBe(53.403);
-  });
-
-  it('treats 110.273 as true decimal seconds (frac > 0.59)', () => {
-    expect(normalizeGeminiTime(110.273, CHUNK)).toBe(110.273);
-  });
-
-  it('treats 12.396 as true decimal seconds (frac > 0.59)', () => {
-    expect(normalizeGeminiTime(12.396, CHUNK)).toBe(12.396);
-  });
-
-  it('treats 0.7 as true decimal seconds (frac > 0.59)', () => {
-    expect(normalizeGeminiTime(0.7, CHUNK)).toBe(0.7);
-  });
-
-  // --- MM.SS overflows chunk → falls back to decimal seconds ---
-
-  it('falls back to decimal seconds when MM.SS result exceeds chunk duration', () => {
-    // 2.30 as MM.SS = 2min 30sec = 150s, which exceeds 120s chunk → use 2.30 as-is
-    expect(normalizeGeminiTime(2.3, CHUNK)).toBe(2.3);
-  });
-
-  it('falls back to decimal for value already near chunk boundary', () => {
-    // 2.00 as MM.SS = 120s, which equals chunk duration (not < chunk) → use 2.00 as-is
-    expect(normalizeGeminiTime(2.0, CHUNK)).toBe(2.0);
-  });
-
-  // --- Edge: large chunk duration ---
-
-  it('converts MM.SS correctly when chunk is large enough to contain it', () => {
-    // 12.05 as MM.SS = 12min 5sec = 725s, within a 900s chunk
-    expect(normalizeGeminiTime(12.05, 900)).toBe(725);
-  });
-});

package/tests/cache.test.ts

@@ -1,203 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'fs';
-import os from 'os';
-import path from 'path';
-import { Cache } from '../src/utils/cache.js';
-import type { TranscriptLine, LLMChunk, ChunkEvaluation, AudioEvent } from '../src/types/index.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function tmpDir(): string {
-  return path.join(os.tmpdir(), `cache-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-}
-
-const TRANSCRIPT_LINE: TranscriptLine = { text: 'hello world', start: 0, duration: 2 };
-
-const LLM_CHUNK: LLMChunk = {
-  start: 0,
-  end: 120,
-  text: 'some transcript text',
-};
-
-const CHUNK_EVALUATION: ChunkEvaluation = {
-  status: 'success',
-  chunk_index: 0,
-  chunk_start: 0,
-  chunk_end: 120,
-  interesting: true,
-  score: 8,
-  reason: 'great moment',
-  clip_start: 10,
-  clip_end: 40,
-};
-
-const AUDIO_EVENT: AudioEvent = {
-  time: 30,
-  event: 'gunshot',
-  confidence: 0.9,
-  source: 'gemini',
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('Cache', () => {
-  let cacheDir: string;
-  let cache: Cache;
-
-  beforeEach(async () => {
-    cacheDir = tmpDir();
-    await fs.mkdir(cacheDir, { recursive: true });
-    cache = new Cache(cacheDir);
-  });
-
-  afterEach(async () => {
-    await fs.rm(cacheDir, { recursive: true, force: true });
-  });
-
-  // ── Transcript ────────────────────────────────────────────────────────────
-
-  describe('transcript', () => {
-    it('returns null on cache miss', async () => {
-      const result = await cache.readTranscript('abc12345678');
-      expect(result).toBeNull();
-    });
-
-    it('round-trips transcript lines', async () => {
-      const lines: TranscriptLine[] = [TRANSCRIPT_LINE, { text: 'bye', start: 3, duration: 1 }];
-      await cache.writeTranscript('abc12345678', lines);
-      const loaded = await cache.readTranscript('abc12345678');
-      expect(loaded).toEqual(lines);
-    });
-
-    it('different video IDs have independent entries', async () => {
-      const lines1: TranscriptLine[] = [TRANSCRIPT_LINE];
-      const lines2: TranscriptLine[] = [{ text: 'other', start: 5, duration: 1 }];
-      await cache.writeTranscript('aaaaaaaaaaa', lines1);
-      await cache.writeTranscript('bbbbbbbbbbb', lines2);
-
-      expect(await cache.readTranscript('aaaaaaaaaaa')).toEqual(lines1);
-      expect(await cache.readTranscript('bbbbbbbbbbb')).toEqual(lines2);
-    });
-  });
-
-  // ── LLM chunk results ─────────────────────────────────────────────────────
-
-  describe('chunk evaluations', () => {
-    it('returns null on cache miss', async () => {
-      expect(await cache.readChunk(LLM_CHUNK)).toBeNull();
-    });
-
-    it('round-trips a successful evaluation', async () => {
-      await cache.writeChunk(LLM_CHUNK, CHUNK_EVALUATION);
-      const loaded = await cache.readChunk(LLM_CHUNK);
-      expect(loaded).toEqual(CHUNK_EVALUATION);
-    });
-
-    it('does not write failed evaluations', async () => {
-      const failed: ChunkEvaluation = {
-        status: 'failed',
-        chunk_index: 0,
-        chunk_start: 0,
-        chunk_end: 120,
-        error: 'timeout',
-      };
-      await cache.writeChunk(LLM_CHUNK, failed);
-      expect(await cache.readChunk(LLM_CHUNK)).toBeNull();
-    });
-
-    it('different chunks (different text) are independent', async () => {
-      const chunk2: LLMChunk = { ...LLM_CHUNK, text: 'different text' };
-      const eval2: ChunkEvaluation = { ...CHUNK_EVALUATION, score: 5 };
-
-      await cache.writeChunk(LLM_CHUNK, CHUNK_EVALUATION);
-      await cache.writeChunk(chunk2, eval2);
-
-      expect(await cache.readChunk(LLM_CHUNK)).toEqual(CHUNK_EVALUATION);
-      expect(await cache.readChunk(chunk2)).toEqual(eval2);
-    });
-  });
-
-  // ── Audio events ──────────────────────────────────────────────────────────
-
-  describe('audio events', () => {
-    it('returns null on cache miss', async () => {
-      expect(await cache.readAudioEvents('abc12345678', 'fps', 'gemini')).toBeNull();
-    });
-
-    it('round-trips audio events', async () => {
-      const events: AudioEvent[] = [AUDIO_EVENT];
-      await cache.writeAudioEvents('abc12345678', 'fps', 'gemini', events);
-      const loaded = await cache.readAudioEvents('abc12345678', 'fps', 'gemini');
-      expect(loaded).toEqual(events);
-    });
-
-    it('different game profiles are independent', async () => {
-      const events1: AudioEvent[] = [AUDIO_EVENT];
-      const events2: AudioEvent[] = [
-        { time: 60, event: 'explosion', confidence: 0.7, source: 'yamnet' },
-      ];
-
-      await cache.writeAudioEvents('abc12345678', 'fps', 'gemini', events1);
-      await cache.writeAudioEvents('abc12345678', 'valorant', 'gemini', events2);
-
-      expect(await cache.readAudioEvents('abc12345678', 'fps', 'gemini')).toEqual(events1);
-      expect(await cache.readAudioEvents('abc12345678', 'valorant', 'gemini')).toEqual(events2);
-    });
-  });
-
-  // ── Disabled mode (--no-cache) ────────────────────────────────────────────
-
-  describe('disabled cache', () => {
-    let disabledCache: Cache;
-
-    beforeEach(() => {
-      disabledCache = new Cache(cacheDir, true);
-    });
-
-    it('always returns null for reads', async () => {
-      // pre-write with enabled cache to confirm disabled cache ignores it
-      await cache.writeTranscript('abc12345678', [TRANSCRIPT_LINE]);
-      expect(await disabledCache.readTranscript('abc12345678')).toBeNull();
-    });
-
-    it('silently skips writes', async () => {
-      // No error thrown, file is not written
-      await disabledCache.writeTranscript('abc12345678', [TRANSCRIPT_LINE]);
-      expect(await cache.readTranscript('abc12345678')).toBeNull();
-    });
-
-    it('returns null for chunk reads', async () => {
-      await cache.writeChunk(LLM_CHUNK, CHUNK_EVALUATION);
-      expect(await disabledCache.readChunk(LLM_CHUNK)).toBeNull();
-    });
-
-    it('returns null for audio event reads', async () => {
-      await cache.writeAudioEvents('abc12345678', 'fps', 'gemini', [AUDIO_EVENT]);
-      expect(await disabledCache.readAudioEvents('abc12345678', 'fps', 'gemini')).toBeNull();
-    });
-  });
-
-  // ── Corrupt cache handling ────────────────────────────────────────────────
-
-  describe('corrupt cache entries', () => {
-    it('returns null and does not throw for corrupt transcript JSON', async () => {
-      const corruptPath = path.join(cacheDir, 'transcript');
-      await fs.mkdir(corruptPath, { recursive: true });
-      // Write a file that will match the expected hash path
-      const hash = await getTranscriptHash('abc12345678');
-      await fs.writeFile(path.join(corruptPath, `${hash}.json`), 'NOT VALID JSON', 'utf-8');
-
-      expect(await cache.readTranscript('abc12345678')).toBeNull();
-    });
-  });
-});
-
-// Helper: compute the same sha256 hash the Cache class uses internally
-async function getTranscriptHash(videoId: string): Promise<string> {
-  const { createHash } = await import('node:crypto');
-  return createHash('sha256').update(videoId).digest('hex');
-}