eprec 0.0.1 → 1.1.0

package/process-course/cli.ts

@@ -0,0 +1,236 @@
+import path from 'node:path'
+import yargs from 'yargs/yargs'
+import { hideBin } from 'yargs/helpers'
+import type { Argv, Arguments } from 'yargs'
+import { getDefaultWhisperModelPath } from '../whispercpp-transcribe'
+import { DEFAULT_MIN_CHAPTER_SECONDS, TRANSCRIPTION_PHRASES } from './config'
+import { normalizeSkipPhrases } from './utils/transcript'
+import { parseChapterSelection } from './utils/chapter-selection'
+import type { ChapterSelection } from './types'
+
+export interface CliArgs {
+	inputPaths: string[]
+	outputDir: string | null
+	minChapterDurationSeconds: number
+	dryRun: boolean
+	keepIntermediates: boolean
+	writeLogs: boolean
+	enableTranscription: boolean
+	whisperModelPath: string
+	whisperLanguage: string
+	whisperBinaryPath: string | undefined
+	whisperSkipPhrases: string[]
+	chapterSelection: ChapterSelection | null
+	shouldExit: boolean
+}
+
+export function configureProcessCommand(
+	command: Argv,
+	defaultWhisperModelPath = getDefaultWhisperModelPath(),
+) {
+	return command
+		.positional('input', {
+			type: 'string',
+			array: true,
+			describe: 'Input video file(s)',
+		})
+		.option('output-dir', {
+			type: 'string',
+			alias: 'o',
+			describe:
+				'Output directory (optional - if not specified, creates directory next to each input file)',
+		})
+		.option('min-chapter-seconds', {
+			type: 'number',
+			alias: 'm',
+			describe: 'Skip chapters shorter than this duration in seconds',
+			default: DEFAULT_MIN_CHAPTER_SECONDS,
+		})
+		.option('dry-run', {
+			type: 'boolean',
+			alias: 'd',
+			describe: 'Skip writing output files and running ffmpeg',
+			default: false,
+		})
+		.option('keep-intermediates', {
+			type: 'boolean',
+			alias: 'k',
+			describe: 'Keep intermediate files for debugging',
+			default: false,
+		})
+		.option('write-logs', {
+			type: 'boolean',
+			alias: 'l',
+			describe: 'Write log files when skipping/fallbacks happen',
+			default: false,
+		})
+		.option('enable-transcription', {
+			type: 'boolean',
+			describe: 'Enable whisper.cpp transcription skip checks',
+			default: true,
+		})
+		.option('whisper-model-path', {
+			type: 'string',
+			describe: 'Path to whisper.cpp model file',
+			default: defaultWhisperModelPath,
+		})
+		.option('whisper-language', {
+			type: 'string',
+			describe: 'Language passed to whisper.cpp',
+			default: 'en',
+		})
+		.option('whisper-binary-path', {
+			type: 'string',
+			describe: 'Path to whisper.cpp CLI (whisper-cli)',
+		})
+		.option('whisper-skip-phrase', {
+			type: 'string',
+			array: true,
+			describe: 'Phrase to skip chapters when found in transcript (repeatable)',
+			default: TRANSCRIPTION_PHRASES,
+		})
+		.option('chapter', {
+			type: 'string',
+			array: true,
+			alias: 'c',
+			describe: 'Only process selected chapters (e.g. 4, 4-6, 4,6,9-12, 4-*)',
+		})
+}
+
+export function normalizeProcessArgs(
+	argv: Arguments,
+	defaultWhisperModelPath = getDefaultWhisperModelPath(),
+): CliArgs {
+	let inputPaths = Array.isArray(argv.input)
+		? argv.input.filter((p): p is string => typeof p === 'string')
+		: typeof argv.input === 'string'
+			? [argv.input]
+			: []
+
+	// If output-dir is not explicitly set, check if the last positional arg
+	// doesn't look like a video file (no video extension). If so, treat it as the output directory
+	let outputDir =
+		typeof argv['output-dir'] === 'string' &&
+		argv['output-dir'].trim().length > 0
+			? argv['output-dir']
+			: null
+
+	if (!outputDir && inputPaths.length > 0) {
+		const outputCandidate = inputPaths.at(-1)
+		if (outputCandidate !== undefined) {
+			const videoExtensions = [
+				'.mp4',
+				'.mkv',
+				'.avi',
+				'.mov',
+				'.webm',
+				'.flv',
+				'.m4v',
+			]
+			const hasVideoExtension = videoExtensions.some((ext) =>
+				outputCandidate.toLowerCase().endsWith(ext),
+			)
+
+			if (!hasVideoExtension) {
+				// Last argument is likely the output directory
+				outputDir = outputCandidate
+				inputPaths = inputPaths.slice(0, -1) // Remove the last argument from inputs
+			}
+		}
+	}
+
+	if (inputPaths.length === 0) {
+		throw new Error('At least one input file is required.')
+	}
+
+	const minChapterDurationSeconds = Number(argv['min-chapter-seconds'])
+	if (
+		!Number.isFinite(minChapterDurationSeconds) ||
+		minChapterDurationSeconds < 0
+	) {
+		throw new Error('min-chapter-seconds must be a non-negative number.')
+	}
+
+	return {
+		inputPaths,
+		outputDir,
+		minChapterDurationSeconds,
+		dryRun: Boolean(argv['dry-run']),
+		keepIntermediates: Boolean(argv['keep-intermediates']),
+		writeLogs: Boolean(argv['write-logs']),
+		enableTranscription: Boolean(argv['enable-transcription']),
+		whisperModelPath:
+			typeof argv['whisper-model-path'] === 'string' &&
+			argv['whisper-model-path'].trim().length > 0
+				? argv['whisper-model-path']
+				: defaultWhisperModelPath,
+		whisperLanguage:
+			typeof argv['whisper-language'] === 'string' &&
+			argv['whisper-language'].trim().length > 0
+				? argv['whisper-language'].trim()
+				: 'en',
+		whisperBinaryPath:
+			typeof argv['whisper-binary-path'] === 'string' &&
+			argv['whisper-binary-path'].trim().length > 0
+				? argv['whisper-binary-path'].trim()
+				: undefined,
+		whisperSkipPhrases: normalizeSkipPhrases(argv['whisper-skip-phrase']),
+		chapterSelection:
+			argv.chapter === undefined ? null : parseChapterSelection(argv.chapter),
+		shouldExit: false,
+	} as CliArgs
+}
+
+export function parseCliArgs(rawArgs = hideBin(process.argv)): CliArgs {
+	const defaultWhisperModelPath = getDefaultWhisperModelPath()
+	const parser = yargs(rawArgs)
+		.scriptName('process-course-video')
+		.usage(
+			"Usage: $0 <input.mp4|input.mkv> [input2.mp4 ...] [output-dir] [--output-dir <dir>] [--min-chapter-seconds <number>] [--dry-run] [--keep-intermediates] [--write-logs] [--enable-transcription]\n  If the last positional argument doesn't have a video extension, it's treated as the output directory.",
+		)
+		.command(
+			'$0 <input...>',
+			'Process chapters into separate files',
+			(command: Argv) =>
+				configureProcessCommand(command, defaultWhisperModelPath),
+		)
+		.check((args: Arguments) => {
+			const minChapterSeconds = args['min-chapter-seconds']
+			if (minChapterSeconds !== undefined) {
+				if (
+					typeof minChapterSeconds !== 'number' ||
+					!Number.isFinite(minChapterSeconds) ||
+					minChapterSeconds < 0
+				) {
+					throw new Error('min-chapter-seconds must be a non-negative number.')
+				}
+			}
+			return true
+		})
+		.strict()
+		.help()
+
+	if (rawArgs.length === 0) {
+		parser.showHelp((message) => {
+			console.log(message)
+		})
+		return {
+			inputPaths: [],
+			outputDir: null,
+			minChapterDurationSeconds: DEFAULT_MIN_CHAPTER_SECONDS,
+			dryRun: false,
+			keepIntermediates: false,
+			writeLogs: false,
+			enableTranscription: true,
+			whisperModelPath: defaultWhisperModelPath,
+			whisperLanguage: 'en',
+			whisperBinaryPath: undefined,
+			whisperSkipPhrases: TRANSCRIPTION_PHRASES,
+			chapterSelection: null,
+			shouldExit: true,
+		}
+	}
+
+	const argv = parser.parseSync()
+	return normalizeProcessArgs(argv, defaultWhisperModelPath)
+}

package/process-course/config.ts

@@ -0,0 +1,50 @@
+export const CONFIG = {
+	preSpeechPaddingSeconds: 0.25,
+	postSpeechPaddingSeconds: 0.35,
+	rawTrimPaddingSeconds: 0.1,
+	vadSampleRate: 16000,
+	vadWindowSamples: 512,
+	vadSpeechThreshold: 0.65,
+	vadNegThreshold: 0.55,
+	vadMinSpeechDurationMs: 250,
+	vadMinSilenceDurationMs: 120,
+	vadSpeechPadMs: 10,
+	vadModelUrl:
+		'https://huggingface.co/freddyaboulton/silero-vad/resolve/main/silero_vad.onnx',
+	normalizePrefilterEnabled: true,
+	normalizePrefilter: 'highpass=f=80,afftdn',
+	loudnessTargetI: -16,
+	loudnessTargetLra: 11,
+	loudnessTargetTp: -1.5,
+	videoReencodeForAccurateTrim: false,
+	audioCodec: 'aac',
+	audioBitrate: '192k',
+	commandTrimPaddingSeconds: 0.25,
+	commandSpliceReencode: true,
+	commandSilenceSearchSeconds: 0.6,
+	commandSilenceMinDurationMs: 120,
+	commandSilenceRmsWindowMs: 6,
+	commandSilenceRmsThreshold: 0.035,
+	commandSilenceMaxBackwardSeconds: 0.2,
+	commandTailMaxSeconds: 12,
+	// Transcript analysis
+	minTranscriptWords: 10,
+	// Trim window validation
+	minTrimWindowSeconds: 0.05,
+} as const
+
+export const EDIT_CONFIG = {
+	speechBoundaryPaddingMs: 125,
+	speechSearchWindowSeconds: 2.0,
+	silenceSearchStartSeconds: 0.1,
+	silenceSearchStepSeconds: 0.1,
+	silenceSearchMaxSeconds: 2.0,
+	autoCreateEditsDirectory: true,
+	keepEditIntermediates: false,
+} as const
+
+export const DEFAULT_MIN_CHAPTER_SECONDS = 15
+export const TRANSCRIPTION_PHRASES = ['jarvis bad take', 'bad take jarvis']
+export const COMMAND_WAKE_WORD = 'jarvis'
+export const COMMAND_CLOSE_WORD = 'thanks'
+export const TRANSCRIPTION_SAMPLE_RATE = 16000

package/process-course/edits/cli.ts

@@ -0,0 +1,167 @@
+#!/usr/bin/env bun
+import type { Argv, Arguments, CommandBuilder, CommandHandler } from 'yargs'
+import yargs from 'yargs/yargs'
+import { hideBin } from 'yargs/helpers'
+import { editVideo, buildEditedOutputPath } from './video-editor'
+import { combineVideos } from './combined-video-editor'
+
+export type EditVideoCommandArgs = {
+	input: string
+	transcript: string
+	edited: string
+	output?: string
+	'padding-ms'?: number
+}
+
+export type CombineVideosCommandArgs = {
+	video1: string
+	transcript1?: string
+	edited1?: string
+	video2: string
+	transcript2?: string
+	edited2?: string
+	output: string
+	'padding-ms'?: number
+}
+
+export function configureEditVideoCommand(command: Argv) {
+	return command
+		.option('input', {
+			type: 'string',
+			demandOption: true,
+			describe: 'Input video file',
+		})
+		.option('transcript', {
+			type: 'string',
+			demandOption: true,
+			describe: 'Transcript JSON path',
+		})
+		.option('edited', {
+			type: 'string',
+			demandOption: true,
+			describe: 'Edited transcript text path',
+		})
+		.option('output', {
+			type: 'string',
+			describe: 'Output video path (defaults to .edited)',
+		})
+		.option('padding-ms', {
+			type: 'number',
+			describe: 'Padding around speech boundaries in ms',
+		})
+}
+
+export async function handleEditVideoCommand(argv: Arguments) {
+	const args = argv as EditVideoCommandArgs
+	const outputPath =
+		typeof args.output === 'string' && args.output.trim().length > 0
+			? args.output
+			: buildEditedOutputPath(String(args.input))
+	const result = await editVideo({
+		inputPath: String(args.input),
+		transcriptJsonPath: String(args.transcript),
+		editedTextPath: String(args.edited),
+		outputPath,
+		paddingMs:
+			typeof args['padding-ms'] === 'number' ? args['padding-ms'] : undefined,
+	})
+	if (!result.success) {
+		console.error(result.error ?? 'Edit failed.')
+		process.exit(1)
+	}
+	console.log(`Edited video written to ${outputPath}`)
+}
+
+export function configureCombineVideosCommand(command: Argv) {
+	return command
+		.option('video1', {
+			type: 'string',
+			demandOption: true,
+			describe: 'First video path',
+		})
+		.option('transcript1', {
+			type: 'string',
+			describe: 'Transcript JSON for first video',
+		})
+		.option('edited1', {
+			type: 'string',
+			describe: 'Edited transcript text for first video',
+		})
+		.option('video2', {
+			type: 'string',
+			demandOption: true,
+			describe: 'Second video path',
+		})
+		.option('transcript2', {
+			type: 'string',
+			describe: 'Transcript JSON for second video',
+		})
+		.option('edited2', {
+			type: 'string',
+			describe: 'Edited transcript text for second video',
+		})
+		.option('output', {
+			type: 'string',
+			demandOption: true,
+			describe: 'Output video path',
+		})
+		.option('padding-ms', {
+			type: 'number',
+			describe: 'Padding around speech boundaries in ms',
+		})
+}
+
+export async function handleCombineVideosCommand(argv: Arguments) {
+	const args = argv as CombineVideosCommandArgs
+	const result = await combineVideos({
+		video1Path: String(args.video1),
+		video1TranscriptJsonPath:
+			typeof args.transcript1 === 'string' ? args.transcript1 : undefined,
+		video1EditedTextPath:
+			typeof args.edited1 === 'string' ? args.edited1 : undefined,
+		video2Path: String(args.video2),
+		video2TranscriptJsonPath:
+			typeof args.transcript2 === 'string' ? args.transcript2 : undefined,
+		video2EditedTextPath:
+			typeof args.edited2 === 'string' ? args.edited2 : undefined,
+		outputPath: String(args.output),
+		overlapPaddingMs:
+			typeof args['padding-ms'] === 'number' ? args['padding-ms'] : undefined,
+	})
+	if (!result.success) {
+		console.error(result.error ?? 'Combine failed.')
+		process.exit(1)
+	}
+	console.log(`Combined video written to ${result.outputPath}`)
+}
+
+export async function runEditsCli() {
+	const parser = yargs(hideBin(process.argv))
+		.scriptName('video-edits')
+		.command(
+			'edit-video',
+			'Edit a single video using transcript text edits',
+			configureEditVideoCommand as CommandBuilder,
+			handleEditVideoCommand as CommandHandler,
+		)
+		.command(
+			'combine-videos',
+			'Combine two videos with speech-aligned padding',
+			configureCombineVideosCommand as CommandBuilder,
+			handleCombineVideosCommand as CommandHandler,
+		)
+		.demandCommand(1)
+		.strict()
+		.help()
+
+	await parser.parseAsync()
+}
+
+if (import.meta.main) {
+	runEditsCli().catch((error) => {
+		console.error(
+			`[error] ${error instanceof Error ? error.message : String(error)}`,
+		)
+		process.exit(1)
+	})
+}