eprec 0.0.1 → 1.0.1

package/process-course/summary.ts

@@ -0,0 +1,210 @@
+import path from 'node:path'
+import { formatSeconds } from '../utils'
+import {
+	buildSummaryLogPath,
+	buildJarvisWarningLogPath,
+	buildJarvisEditLogPath,
+	buildJarvisNoteLogPath,
+} from './paths'
+import { logInfo } from './logging'
+import type {
+	Chapter,
+	JarvisWarning,
+	JarvisEdit,
+	JarvisNote,
+	EditWorkspaceInfo,
+} from './types'
+
+export type ProcessingSummary = {
+	totalSelected: number
+	processed: number
+	skippedShortInitial: number
+	skippedShortTrimmed: number
+	skippedTranscription: number
+	fallbackNotes: number
+	logsWritten: number
+	jarvisWarnings: number
+	editsPending: number
+}
+
+export async function writeJarvisLogs(options: {
+	outputDir: string
+	inputPath: string
+	jarvisWarnings: JarvisWarning[]
+	jarvisEdits: JarvisEdit[]
+	jarvisNotes: JarvisNote[]
+	editWorkspaces: EditWorkspaceInfo[]
+	dryRun: boolean
+}) {
+	const {
+		outputDir,
+		inputPath,
+		jarvisWarnings,
+		jarvisEdits,
+		jarvisNotes,
+		editWorkspaces,
+		dryRun,
+	} = options
+
+	const jarvisWarningLogPath = buildJarvisWarningLogPath(outputDir)
+	if (dryRun) {
+		logInfo(`[dry-run] Would write jarvis warning log: ${jarvisWarningLogPath}`)
+	} else {
+		const warningLines = [
+			`Input: ${inputPath}`,
+			`Output dir: ${outputDir}`,
+			`Jarvis warnings: ${jarvisWarnings.length}`,
+		]
+		if (jarvisWarnings.length > 0) {
+			warningLines.push('Detected in:')
+			jarvisWarnings.forEach((warning) => {
+				warningLines.push(
+					`- Chapter ${warning.chapter.index + 1}: ${warning.chapter.title} -> ${path.basename(
+						warning.outputPath,
+					)}`,
+				)
+				const timestampLabel =
+					warning.timestamps.length > 0
+						? warning.timestamps
+								.map(
+									(timestamp) =>
+										`${formatSeconds(timestamp.start)}-${formatSeconds(timestamp.end)}`,
+								)
+								.join(', ')
+						: 'unavailable'
+				warningLines.push(`  Jarvis timestamps: ${timestampLabel}`)
+			})
+		} else {
+			warningLines.push('Detected in: none')
+		}
+		await Bun.write(jarvisWarningLogPath, `${warningLines.join('\n')}\n`)
+	}
+
+	const jarvisEditLogPath = buildJarvisEditLogPath(outputDir)
+	if (dryRun) {
+		logInfo(`[dry-run] Would write jarvis edit log: ${jarvisEditLogPath}`)
+	} else {
+		const editLines = [
+			`Input: ${inputPath}`,
+			`Output dir: ${outputDir}`,
+			`Edit commands: ${jarvisEdits.length}`,
+			`Manual edits: ${editWorkspaces.length}`,
+		]
+		if (jarvisEdits.length > 0) {
+			editLines.push('Files needing edits:')
+			jarvisEdits.forEach((edit) => {
+				editLines.push(
+					`- Chapter ${edit.chapter.index + 1}: ${edit.chapter.title} -> ${path.basename(
+						edit.outputPath,
+					)}`,
+				)
+			})
+		} else {
+			editLines.push('Files needing edits: none')
+		}
+		if (editWorkspaces.length > 0) {
+			editLines.push('Edit workspaces:')
+			editWorkspaces.forEach((workspace) => {
+				editLines.push(
+					`- Chapter ${workspace.chapter.index + 1}: ${workspace.chapter.title} -> ${path.basename(
+						workspace.outputPath,
+					)}`,
+				)
+				editLines.push(`  Reason: ${workspace.reason}`)
+				editLines.push(`  Directory: ${workspace.editsDirectory}`)
+			})
+		} else {
+			editLines.push('Edit workspaces: none')
+		}
+		await Bun.write(jarvisEditLogPath, `${editLines.join('\n')}\n`)
+	}
+
+	const jarvisNoteLogPath = buildJarvisNoteLogPath(outputDir)
+	if (dryRun) {
+		logInfo(`[dry-run] Would write jarvis note log: ${jarvisNoteLogPath}`)
+	} else {
+		const noteLines = [
+			`Input: ${inputPath}`,
+			`Output dir: ${outputDir}`,
+			`Note commands: ${jarvisNotes.length}`,
+		]
+		if (jarvisNotes.length > 0) {
+			noteLines.push('Notes:')
+			jarvisNotes.forEach((note) => {
+				noteLines.push(
+					`- Chapter ${note.chapter.index + 1}: ${note.chapter.title} -> ${path.basename(
+						note.outputPath,
+					)}`,
+				)
+				noteLines.push(`  Note: ${note.note}`)
+			})
+		} else {
+			noteLines.push('Notes: none')
+		}
+		await Bun.write(jarvisNoteLogPath, `${noteLines.join('\n')}\n`)
+	}
+}
+
+export async function writeSummaryLogs(options: {
+	tmpDir: string
+	outputDir: string
+	inputPath: string
+	summary: ProcessingSummary
+	summaryDetails: string[]
+	jarvisWarnings: JarvisWarning[]
+	jarvisEdits: JarvisEdit[]
+	editWorkspaces: EditWorkspaceInfo[]
+	dryRun: boolean
+}) {
+	const {
+		tmpDir,
+		outputDir,
+		inputPath,
+		summary,
+		summaryDetails,
+		jarvisWarnings,
+		jarvisEdits,
+		editWorkspaces,
+		dryRun,
+	} = options
+
+	const summaryLines = [
+		`Input: ${inputPath}`,
+		`Output dir: ${outputDir}`,
+		`Chapters selected: ${summary.totalSelected}`,
+		`${dryRun ? 'Would process' : 'Processed'} chapters: ${summary.processed}`,
+		`Skipped (short initial): ${summary.skippedShortInitial}`,
+		`Skipped (trimmed short): ${summary.skippedShortTrimmed}`,
+		`Skipped (transcription): ${summary.skippedTranscription}`,
+		`Fallback notes: ${summary.fallbackNotes}`,
+		`Log files written: ${summary.logsWritten}`,
+		`Jarvis warnings: ${summary.jarvisWarnings}`,
+		`Manual edits: ${summary.editsPending}`,
+	]
+	if (editWorkspaces.length > 0) {
+		summaryLines.push('Edit workspaces:')
+		editWorkspaces.forEach((workspace) => {
+			summaryLines.push(
+				`- Chapter ${workspace.chapter.index + 1}: ${workspace.chapter.title} -> ${path.basename(
+					workspace.outputPath,
+				)}`,
+			)
+			summaryLines.push(`  Reason: ${workspace.reason}`)
+			summaryLines.push(`  Directory: ${workspace.editsDirectory}`)
+		})
+	}
+	if (summaryDetails.length > 0) {
+		summaryLines.push('Details:', ...summaryDetails)
+	}
+
+	logInfo('Summary:')
+	summaryLines.forEach((line) => logInfo(line))
+
+	if (dryRun) {
+		const summaryLogPath = buildSummaryLogPath(tmpDir)
+		logInfo(`[dry-run] Would write summary log: ${summaryLogPath}`)
+	} else {
+		const summaryLogPath = buildSummaryLogPath(tmpDir)
+		await Bun.write(summaryLogPath, `${summaryLines.join('\n')}\n`)
+	}
+}

package/process-course/types.ts

@@ -0,0 +1,85 @@
+export type Chapter = {
+	index: number
+	start: number
+	end: number
+	title: string
+}
+
+export type LoudnormAnalysis = {
+	input_i: string
+	input_tp: string
+	input_lra: string
+	input_thresh: string
+	target_offset: string
+}
+
+export type SpeechBounds = {
+	start: number
+	end: number
+	note?: string
+}
+
+export type TimeRange = {
+	start: number
+	end: number
+}
+
+export type SilenceBoundaryDirection = 'before' | 'after'
+
+export type JarvisWarning = {
+	chapter: Chapter
+	outputPath: string
+	timestamps: TimeRange[]
+}
+
+export type JarvisEdit = {
+	chapter: Chapter
+	outputPath: string
+}
+
+export type EditReason = 'edit-command' | 'combine-previous' | 'jarvis-warning'
+
+export type EditWorkspaceInfo = {
+	chapter: Chapter
+	outputPath: string
+	reason: EditReason
+	editsDirectory: string
+	transcriptTextPath: string
+	transcriptJsonPath: string
+	originalVideoPath: string
+	instructionsPath: string
+}
+
+export type ChapterRange = {
+	start: number
+	end: number | null
+}
+
+export type ChapterSelection = {
+	base: 0 | 1
+	ranges: ChapterRange[]
+}
+
+// Re-export from jarvis-commands for backward compatibility
+export type { TranscriptCommand, TranscriptWord } from './jarvis-commands/types'
+
+export type JarvisNote = {
+	chapter: Chapter
+	outputPath: string
+	note: string
+	timestamp: number
+}
+
+export type JarvisSplit = {
+	chapter: Chapter
+	outputPath: string
+	timestamp: number
+}
+
+export type ProcessedChapterInfo = {
+	chapter: Chapter
+	outputPath: string
+	// The path to the normalized/processed video before final trimming
+	processedPath: string
+	processedDuration: number
+}

package/process-course/utils/audio-analysis.test.ts

@@ -0,0 +1,348 @@
+import { test, expect } from 'bun:test'
+import {
+	buildSilenceGapsFromSpeech,
+	computeMinWindowRms,
+	computeRms,
+	findLowestAmplitudeBoundaryProgressive,
+	findLowestAmplitudeOffset,
+	findSilenceBoundaryFromGaps,
+	findSilenceBoundaryProgressive,
+	findSilenceBoundaryWithRms,
+	findSpeechEndWithRms,
+	findSpeechStartWithRms,
+	speechFallback,
+} from './audio-analysis'
+import type { TimeRange } from '../types'
+
+// Factory function for creating audio samples
+function createSamples(...values: number[]): Float32Array {
+	return new Float32Array(values)
+}
+
+function createUniformSamples(value: number, length: number): Float32Array {
+	return new Float32Array(length).fill(value)
+}
+
+function createRange(start: number, end: number): TimeRange {
+	return { start, end }
+}
+
+function createRanges(...pairs: [number, number][]): TimeRange[] {
+	return pairs.map(([start, end]) => createRange(start, end))
+}
+
+function createRmsOptions(
+	samples: number[],
+	direction: 'before' | 'after',
+	overrides: Partial<{
+		sampleRate: number
+		rmsWindowMs: number
+		rmsThreshold: number
+		minSilenceMs: number
+	}> = {},
+) {
+	return {
+		samples: createSamples(...samples),
+		sampleRate: overrides.sampleRate ?? 10,
+		direction,
+		rmsWindowMs: overrides.rmsWindowMs ?? 100,
+		rmsThreshold: overrides.rmsThreshold ?? 0.5,
+		minSilenceMs: overrides.minSilenceMs ?? 200,
+	}
+}
+
+function createProgressiveOptions(
+	samples: number[],
+	direction: 'before' | 'after',
+	overrides: Partial<{
+		sampleRate: number
+		startWindowSeconds: number
+		stepSeconds: number
+		maxWindowSeconds: number
+		rmsWindowMs: number
+		rmsThreshold: number
+		minSilenceMs: number
+	}> = {},
+) {
+	const sampleRate = overrides.sampleRate ?? 10
+	const maxWindowSeconds =
+		overrides.maxWindowSeconds ?? samples.length / sampleRate
+	return {
+		samples: createSamples(...samples),
+		sampleRate,
+		direction,
+		startWindowSeconds: overrides.startWindowSeconds ?? 0.2,
+		stepSeconds: overrides.stepSeconds ?? 0.2,
+		maxWindowSeconds,
+		rmsWindowMs: overrides.rmsWindowMs ?? 100,
+		rmsThreshold: overrides.rmsThreshold ?? 0.5,
+		minSilenceMs: overrides.minSilenceMs ?? 100,
+	}
+}
+
+// computeRms tests
+test('computeRms returns 0 for empty array', () => {
+	expect(computeRms(createSamples())).toBe(0)
+})
+
+test('computeRms returns 0 for all zeros', () => {
+	expect(computeRms(createSamples(0, 0, 0, 0))).toBe(0)
+})
+
+test('computeRms computes correct value for uniform samples', () => {
+	expect(computeRms(createSamples(1, 1, 1, 1))).toBe(1)
+})
+
+test('computeRms computes correct value for [3, 4]', () => {
+	const samples = createSamples(3, 4)
+	expect(computeRms(samples)).toBeCloseTo(Math.sqrt(12.5))
+})
+
+test('computeRms handles negative values correctly', () => {
+	expect(computeRms(createSamples(-1, -1, -1, -1))).toBe(1)
+})
+
+test('computeRms handles mixed positive and negative values', () => {
+	expect(computeRms(createSamples(1, -1, 1, -1))).toBe(1)
+})
+
+test('computeRms computes correct value for single sample', () => {
+	expect(computeRms(createSamples(5))).toBe(5)
+})
+
+test('computeRms computes correct value for typical audio samples', () => {
+	const samples = createSamples(0.5, -0.3, 0.8, -0.2, 0.1)
+	const expectedSumSquares = 0.25 + 0.09 + 0.64 + 0.04 + 0.01
+	const expectedRms = Math.sqrt(expectedSumSquares / 5)
+	expect(computeRms(samples)).toBeCloseTo(expectedRms)
+})
+
+test('computeRms handles very small values', () => {
+	const samples = createSamples(0.001, 0.002, 0.001, 0.002)
+	const rms = computeRms(samples)
+	expect(rms).toBeGreaterThan(0)
+	expect(rms).toBeLessThan(0.01)
+})
+
+// computeMinWindowRms tests
+test('computeMinWindowRms returns 0 for empty array', () => {
+	expect(computeMinWindowRms(createSamples(), 10)).toBe(0)
+})
+
+test('computeMinWindowRms returns 0 for zero window size', () => {
+	expect(computeMinWindowRms(createSamples(1, 2, 3), 0)).toBe(0)
+})
+
+test('computeMinWindowRms returns 0 for negative window size', () => {
+	expect(computeMinWindowRms(createSamples(1, 2, 3), -5)).toBe(0)
+})
+
+test('computeMinWindowRms returns full RMS when window exceeds samples', () => {
+	const samples = createSamples(1, 2, 3)
+	expect(computeMinWindowRms(samples, 5)).toBe(computeRms(samples))
+})
+
+test('computeMinWindowRms returns full RMS when window equals samples', () => {
+	const samples = createSamples(1, 2, 3)
+	expect(computeMinWindowRms(samples, 3)).toBe(computeRms(samples))
+})
+
+test('computeMinWindowRms finds quietest section', () => {
+	// Loud (RMS=1) | Quiet (RMS=0.1) | Loud (RMS=1)
+	const samples = createSamples(1, 1, 1, 1, 0.1, 0.1, 1, 1, 1, 1)
+	expect(computeMinWindowRms(samples, 2)).toBeCloseTo(0.1)
+})
+
+test('computeMinWindowRms with window size 1 finds minimum absolute value', () => {
+	const samples = createSamples(5, 1, 3, 0, 4)
+	expect(computeMinWindowRms(samples, 1)).toBe(0)
+})
+
+test('computeMinWindowRms returns same value for uniform array', () => {
+	const samples = createUniformSamples(0.5, 5)
+	expect(computeMinWindowRms(samples, 2)).toBeCloseTo(0.5)
+})
+
+test('computeMinWindowRms finds minimum at start', () => {
+	const samples = createSamples(0.1, 0.1, 1, 1, 1, 1)
+	expect(computeMinWindowRms(samples, 2)).toBeCloseTo(0.1)
+})
+
+test('computeMinWindowRms finds minimum at end', () => {
+	const samples = createSamples(1, 1, 1, 1, 0.1, 0.1)
+	expect(computeMinWindowRms(samples, 2)).toBeCloseTo(0.1)
+})
+
+test('computeMinWindowRms returns 0 for silence', () => {
+	const samples = createUniformSamples(0, 6)
+	expect(computeMinWindowRms(samples, 3)).toBe(0)
+})
+
+test('computeMinWindowRms handles mixed positive and negative', () => {
+	const samples = createSamples(1, -1, 1, -1, 0.1, -0.1, 1, -1, 1, -1)
+	expect(computeMinWindowRms(samples, 2)).toBeCloseTo(0.1)
+})
+
+test('findSpeechStartWithRms finds first non-silent window', () => {
+	const start = findSpeechStartWithRms({
+		samples: createSamples(0, 0, 0, 1, 1),
+		sampleRate: 10,
+		rmsWindowMs: 100,
+		rmsThreshold: 0.5,
+	})
+	expect(start).toBeCloseTo(0.3, 3)
+})
+
+test('findSpeechStartWithRms returns null for silence', () => {
+	const start = findSpeechStartWithRms({
+		samples: createSamples(0, 0, 0, 0),
+		sampleRate: 10,
+		rmsWindowMs: 100,
+		rmsThreshold: 0.1,
+	})
+	expect(start).toBeNull()
+})
+
+test('findSpeechEndWithRms finds last non-silent window', () => {
+	const end = findSpeechEndWithRms({
+		samples: createSamples(1, 1, 0, 0),
+		sampleRate: 10,
+		rmsWindowMs: 100,
+		rmsThreshold: 0.5,
+	})
+	expect(end).toBeCloseTo(0.2, 3)
+})
+
+test('findSpeechEndWithRms returns null for silence', () => {
+	const end = findSpeechEndWithRms({
+		samples: createSamples(0, 0, 0, 0),
+		sampleRate: 10,
+		rmsWindowMs: 100,
+		rmsThreshold: 0.1,
+	})
+	expect(end).toBeNull()
+})
+
+// buildSilenceGapsFromSpeech tests
+test('buildSilenceGapsFromSpeech returns full gap for no speech', () => {
+	expect(buildSilenceGapsFromSpeech([], 10)).toEqual([createRange(0, 10)])
+})
+
+test('buildSilenceGapsFromSpeech returns gaps between segments', () => {
+	const segments = createRanges([0, 1], [3, 4])
+	expect(buildSilenceGapsFromSpeech(segments, 5)).toEqual(
+		createRanges([1, 3], [4, 5]),
+	)
+})
+
+test('buildSilenceGapsFromSpeech filters tiny gaps', () => {
+	const segments = createRanges([0, 1], [1.0005, 2])
+	expect(buildSilenceGapsFromSpeech(segments, 2)).toEqual([])
+})
+
+// findSilenceBoundaryFromGaps tests
+test('findSilenceBoundaryFromGaps returns target inside gap', () => {
+	const gaps = createRanges([0, 2], [4, 6])
+	expect(findSilenceBoundaryFromGaps(gaps, 1.5, 'before')).toBe(1.5)
+})
+
+test('findSilenceBoundaryFromGaps finds boundary before target', () => {
+	const gaps = createRanges([0, 1], [3, 4])
+	expect(findSilenceBoundaryFromGaps(gaps, 2, 'before')).toBe(1)
+})
+
+test('findSilenceBoundaryFromGaps finds boundary after target', () => {
+	const gaps = createRanges([0, 1], [3, 4])
+	expect(findSilenceBoundaryFromGaps(gaps, 2, 'after')).toBe(3)
+})
+
+test('findSilenceBoundaryFromGaps returns null when none found', () => {
+	const gaps = createRanges([1, 2])
+	expect(findSilenceBoundaryFromGaps(gaps, 0.5, 'before')).toBeNull()
+})
+
+// speechFallback tests
+test('speechFallback returns full duration range with note', () => {
+	expect(speechFallback(12.5, 'fallback')).toEqual({
+		start: 0,
+		end: 12.5,
+		note: 'fallback',
+	})
+})
+
+// findSilenceBoundaryWithRms tests
+test('findSilenceBoundaryWithRms returns null for empty samples', () => {
+	const options = createRmsOptions([], 'after')
+	expect(findSilenceBoundaryWithRms(options)).toBeNull()
+})
+
+test('findSilenceBoundaryWithRms finds silence start for after direction', () => {
+	const options = createRmsOptions([1, 1, 0, 0, 1], 'after')
+	expect(findSilenceBoundaryWithRms(options)).toBeCloseTo(0.2)
+})
+
+test('findSilenceBoundaryWithRms finds silence end for before direction', () => {
+	const options = createRmsOptions([1, 1, 1, 0, 0], 'before')
+	expect(findSilenceBoundaryWithRms(options)).toBeCloseTo(0.5)
+})
+
+test('findSilenceBoundaryWithRms returns null when silence is too short', () => {
+	const options = createRmsOptions([1, 0, 1, 1], 'after')
+	expect(findSilenceBoundaryWithRms(options)).toBeNull()
+})
+
+test('findLowestAmplitudeOffset picks the lowest RMS window', () => {
+	const result = findLowestAmplitudeOffset({
+		samples: createSamples(1, 1, 1, 0, 0, 0),
+		sampleRate: 10,
+		rmsWindowMs: 100,
+	})
+	expect(result).not.toBeNull()
+	expect(result?.offsetSeconds).toBeCloseTo(0.35, 3)
+	expect(result?.rms).toBeLessThan(0.2)
+})
+
+test('findLowestAmplitudeBoundaryProgressive uses closest low amplitude', () => {
+	const options = createProgressiveOptions(
+		[1, 1, 1, 1, 0, 0, 0, 1, 1, 1],
+		'before',
+		{ startWindowSeconds: 0.2, stepSeconds: 0.2, maxWindowSeconds: 1 },
+	)
+	const boundary = findLowestAmplitudeBoundaryProgressive({
+		...options,
+		rmsThreshold: 0.2,
+	})
+	expect(boundary).toBeCloseTo(0.65, 2)
+})
+
+test('findLowestAmplitudeBoundaryProgressive returns null without quiet audio', () => {
+	const options = createProgressiveOptions([1, 1, 1, 1, 1], 'after', {
+		startWindowSeconds: 0.2,
+		stepSeconds: 0.2,
+		maxWindowSeconds: 0.5,
+	})
+	const boundary = findLowestAmplitudeBoundaryProgressive({
+		...options,
+		rmsThreshold: 0.2,
+	})
+	expect(boundary).toBeNull()
+})
+
+test('findSilenceBoundaryProgressive widens window until silence is found', () => {
+	const options = createProgressiveOptions(
+		[1, 1, 1, 1, 1, 0, 0, 1, 1, 1],
+		'before',
+		{ startWindowSeconds: 0.2, stepSeconds: 0.2, maxWindowSeconds: 1 },
+	)
+	const boundary = findSilenceBoundaryProgressive(options)
+	expect(boundary).toBeCloseTo(0.7, 3)
+})
+
+test('findSilenceBoundaryProgressive returns null when no silence exists', () => {
+	const options = createProgressiveOptions([1, 1, 1, 1, 1], 'after', {
+		startWindowSeconds: 0.2,
+		stepSeconds: 0.2,
+		maxWindowSeconds: 0.5,
+	})
+	expect(findSilenceBoundaryProgressive(options)).toBeNull()
+})