eprec 1.2.0 → 1.3.0

package/app/assets/styles.css

@@ -261,7 +261,9 @@ p {
 	cursor: pointer;
 	left: var(--range-left);
 	width: var(--range-width);
-	transition: transform 0.15s ease, box-shadow 0.15s ease;
+	transition:
+		transform 0.15s ease,
+		box-shadow 0.15s ease;
 }
 
 .timeline-range--manual {
@@ -370,7 +372,9 @@ p {
 	font-size: 13px;
 	font-weight: 600;
 	cursor: pointer;
-	transition: background 0.15s ease, color 0.15s ease;
+	transition:
+		background 0.15s ease,
+		color 0.15s ease;
 }
 
 .button--primary {

package/app/client/app.tsx

@@ -1,7 +1,5 @@
 import { EditingWorkspace } from './editing-workspace.tsx'
 
 export function App() {
-	return () => (
-		<EditingWorkspace />
-	)
+	return () => <EditingWorkspace />
 }

package/app/client/editing-workspace.tsx

@@ -27,6 +27,7 @@ export function EditingWorkspace(handle: Handle) {
 	let previewPlaying = false
 	let previewNode: HTMLVideoElement | null = null
 	let lastSyncedPlayhead = playhead
+	let isScrubbing = false
 
 	const setPlayhead = (value: number) => {
 		playhead = clamp(value, 0, duration)
@@ -34,6 +35,16 @@ export function EditingWorkspace(handle: Handle) {
 		handle.update()
 	}
 
+	const startScrubbing = () => {
+		isScrubbing = true
+	}
+
+	const stopScrubbing = () => {
+		if (!isScrubbing) return
+		isScrubbing = false
+		syncVideoToPlayhead(playhead)
+	}
+
 	const selectRange = (rangeId: string) => {
 		selectedRangeId = rangeId
 		handle.update()
@@ -41,7 +52,11 @@ export function EditingWorkspace(handle: Handle) {
 
 	const addManualCut = () => {
 		const start = clamp(playhead, 0, duration - MIN_CUT_LENGTH)
-		const end = clamp(start + DEFAULT_CUT_LENGTH, start + MIN_CUT_LENGTH, duration)
+		const end = clamp(
+			start + DEFAULT_CUT_LENGTH,
+			start + MIN_CUT_LENGTH,
+			duration,
+		)
 		const newRange: CutRange = {
 			id: `manual-${manualCutId++}`,
 			start,
@@ -130,10 +145,19 @@ export function EditingWorkspace(handle: Handle) {
 	}
 
 	const syncVideoToPlayhead = (value: number) => {
-		if (!previewNode || !previewReady || duration <= 0 || previewDuration <= 0) {
+		if (
+			!previewNode ||
+			!previewReady ||
+			duration <= 0 ||
+			previewDuration <= 0
+		) {
 			return
 		}
-		const targetTime = clamp((value / duration) * previewDuration, 0, previewDuration)
+		const targetTime = clamp(
+			(value / duration) * previewDuration,
+			0,
+			previewDuration,
+		)
 		lastSyncedPlayhead = value
 		if (Math.abs(previewNode.currentTime - targetTime) > 0.05) {
 			previewNode.currentTime = targetTime
@@ -143,7 +167,7 @@ export function EditingWorkspace(handle: Handle) {
 	return () => {
 		const sortedCuts = sortRanges(cutRanges)
 		const selectedRange = selectedRangeId
-			? sortedCuts.find((range) => range.id === selectedRangeId) ?? null
+			? (sortedCuts.find((range) => range.id === selectedRangeId) ?? null)
 			: null
 		const mergedCuts = mergeOverlappingRanges(sortedCuts)
 		const totalRemoved = mergedCuts.reduce(
@@ -161,7 +185,10 @@ export function EditingWorkspace(handle: Handle) {
 					.filter((word) => word.word.toLowerCase().includes(query))
 					.slice(0, 12)
 			: []
-		const commandPreview = buildCommandPreview(sampleEditSession.sourceName, chapters)
+		const commandPreview = buildCommandPreview(
+			sampleEditSession.sourceName,
+			chapters,
+		)
 		const previewTime =
 			previewReady && previewDuration > 0
 				? (playhead / duration) * previewDuration
@@ -190,29 +217,29 @@ export function EditingWorkspace(handle: Handle) {
 						</div>
 						<div class="summary-item">
 							<span class="summary-label">Cuts</span>
-							<span class="summary-value">
-								{sortedCuts.length} ranges
-							</span>
+							<span class="summary-value">{sortedCuts.length} ranges</span>
 							<span class="summary-subtext">
 								{formatSeconds(totalRemoved)} removed
 							</span>
 						</div>
 						<div class="summary-item">
 							<span class="summary-label">Output length</span>
-							<span class="summary-value">{formatTimestamp(finalDuration)}</span>
+							<span class="summary-value">
+								{formatTimestamp(finalDuration)}
+							</span>
 							<span class="summary-subtext">
 								{Math.round((finalDuration / duration) * 100)}% retained
 							</span>
 						</div>
 						<div class="summary-item">
 							<span class="summary-label">Commands</span>
-							<span class="summary-value">
-								{commands.length} detected
-							</span>
+							<span class="summary-value">{commands.length} detected</span>
 							<span class="summary-subtext">
-								{commands.filter((command) =>
-									isCommandApplied(command, sortedCuts, chapters),
-								).length}{' '}
+								{
+									commands.filter((command) =>
+										isCommandApplied(command, sortedCuts, chapters),
+									).length
+								}{' '}
 								applied
 							</span>
 						</div>
@@ -228,7 +255,11 @@ export function EditingWorkspace(handle: Handle) {
 								trims.
 							</p>
 						</div>
-						<button class="button button--primary" type="button" on={{ click: addManualCut }}>
+						<button
+							class="button button--primary"
+							type="button"
+							on={{ click: addManualCut }}
+						>
 							Add cut at playhead
 						</button>
 					</div>
@@ -260,11 +291,11 @@ export function EditingWorkspace(handle: Handle) {
 											: 'Loading'}
 									</span>
 								</div>
-							<video
-								class="timeline-video-player"
-								src="/e2e-test.mp4"
-								controls
-								preload="metadata"
+								<video
+									class="timeline-video-player"
+									src="/e2e-test.mp4"
+									controls
+									preload="metadata"
 									connect={(node: HTMLVideoElement, signal) => {
 										previewNode = node
 										const handleLoadedMetadata = () => {
@@ -278,6 +309,8 @@ export function EditingWorkspace(handle: Handle) {
 										}
 										const handleTimeUpdate = () => {
 											if (!previewReady || previewDuration <= 0) return
+											if (isScrubbing) return
+											if (!previewPlaying) return
 											const mapped =
 												(node.currentTime / previewDuration) * duration
 											if (Math.abs(mapped - lastSyncedPlayhead) <= 0.05) {
@@ -294,7 +327,10 @@ export function EditingWorkspace(handle: Handle) {
 											previewPlaying = false
 											handle.update()
 										}
-										node.addEventListener('loadedmetadata', handleLoadedMetadata)
+										node.addEventListener(
+											'loadedmetadata',
+											handleLoadedMetadata,
+										)
 										node.addEventListener('timeupdate', handleTimeUpdate)
 										node.addEventListener('play', handlePlay)
 										node.addEventListener('pause', handlePause)
@@ -313,9 +349,7 @@ export function EditingWorkspace(handle: Handle) {
 									}}
 								/>
 								<div class="timeline-video-meta">
-									<span>
-										Preview {formatTimestamp(previewTime)}
-									</span>
+									<span>Preview {formatTimestamp(previewTime)}</span>
 									<span class="app-muted">
 										Timeline {formatTimestamp(playhead)}
 									</span>
@@ -350,9 +384,7 @@ export function EditingWorkspace(handle: Handle) {
 							<div class="timeline-controls">
 								<label class="control-label">
 									Playhead
-									<span class="control-value">
-										{formatTimestamp(playhead)}
-									</span>
+									<span class="control-value">{formatTimestamp(playhead)}</span>
 								</label>
 								<input
 									class="timeline-slider"
@@ -364,8 +396,15 @@ export function EditingWorkspace(handle: Handle) {
 									on={{
 										input: (event) => {
 											const target = event.currentTarget as HTMLInputElement
+											startScrubbing()
 											setPlayhead(Number(target.value))
 										},
+										pointerdown: startScrubbing,
+										pointerup: stopScrubbing,
+										pointercancel: stopScrubbing,
+										keydown: startScrubbing,
+										keyup: stopScrubbing,
+										blur: stopScrubbing,
 									}}
 								/>
 								<button
@@ -385,7 +424,9 @@ export function EditingWorkspace(handle: Handle) {
 									type="button"
 									on={{
 										click: () => {
-											const next = sortedCuts.find((range) => range.start > playhead)
+											const next = sortedCuts.find(
+												(range) => range.start > playhead,
+											)
 											if (next) setPlayhead(next.start)
 										},
 									}}
@@ -460,7 +501,9 @@ export function EditingWorkspace(handle: Handle) {
 											on={{
 												input: (event) => {
 													const target = event.currentTarget as HTMLInputElement
-													updateCutRange(selectedRange.id, { reason: target.value })
+													updateCutRange(selectedRange.id, {
+														reason: target.value,
+													})
 												},
 											}}
 										/>
@@ -562,7 +605,8 @@ export function EditingWorkspace(handle: Handle) {
 											value={chapter.status}
 											on={{
 												change: (event) => {
-													const target = event.currentTarget as HTMLSelectElement
+													const target =
+														event.currentTarget as HTMLSelectElement
 													updateChapterStatus(
 														chapter.id,
 														target.value as ChapterStatus,

package/cli.ts

@@ -1,11 +1,13 @@
 #!/usr/bin/env bun
 import path from 'node:path'
-import type { CommandBuilder, CommandHandler } from 'yargs'
+import type { Arguments, CommandBuilder, CommandHandler } from 'yargs'
 import yargs from 'yargs/yargs'
 import { hideBin } from 'yargs/helpers'
 import { startAppServer } from './app-server'
+import { setLogHooks } from './process-course/logging'
 import { ensureFfmpegAvailable } from './process-course/ffmpeg'
 import {
+	VIDEO_EXTENSIONS,
 	normalizeProcessArgs,
 	configureProcessCommand,
 } from './process-course/cli'
@@ -13,46 +15,86 @@ import { runProcessCourse } from './process-course-video'
 import {
 	configureEditVideoCommand,
 	configureCombineVideosCommand,
-	handleCombineVideosCommand,
-	handleEditVideoCommand,
+	createCombineVideosHandler,
+	createEditVideoHandler,
 } from './process-course/edits/cli'
 import { detectSpeechSegmentsForFile } from './speech-detection'
 import {
 	getDefaultWhisperModelPath,
 	transcribeAudio,
 } from './whispercpp-transcribe'
+import {
+	PromptCancelled,
+	createInquirerPrompter,
+	createPathPicker,
+	isInteractive,
+	pauseActiveSpinner,
+	resumeActiveSpinner,
+	resolveOptionalString,
+	type PathPicker,
+	type Prompter,
+	withSpinner,
+} from './cli-ux'
 
-function resolveOptionalString(value: unknown) {
-	if (typeof value !== 'string') {
-		return undefined
-	}
-	const trimmed = value.trim()
-	return trimmed.length > 0 ? trimmed : undefined
+type CliUxContext = {
+	interactive: boolean
+	prompter?: Prompter
+	pathPicker?: PathPicker
 }
 
-async function main() {
-	const parser = yargs(hideBin(process.argv))
+async function main(rawArgs = hideBin(process.argv)) {
+	const context = createCliUxContext()
+	let args = rawArgs
+
+	if (context.interactive && args.length === 0 && context.prompter) {
+		const selection = await promptForCommand(context.prompter)
+		if (!selection) {
+			return
+		}
+		args = selection
+	}
+
+	const handlerOptions = {
+		interactive: context.interactive,
+		pathPicker: context.pathPicker,
+	}
+
+	const parser = yargs(args)
 		.scriptName('eprec')
 		.command(
-			'process <input...>',
+			'process [input...]',
 			'Process chapters into separate files',
 			configureProcessCommand,
 			async (argv) => {
-				const args = normalizeProcessArgs(argv)
-				await runProcessCourse(args)
+				const processArgs = await resolveProcessArgs(argv, context)
+				await withSpinner(
+					'Processing course',
+					async () => {
+						setLogHooks({
+							beforeLog: pauseActiveSpinner,
+							afterLog: resumeActiveSpinner,
+						})
+						try {
+							await runProcessCourse(processArgs)
+						} finally {
+							setLogHooks({})
+						}
+					},
+					{ successText: 'Processing complete', enabled: context.interactive },
+				)
 			},
 		)
 		.command(
 			'edit',
 			'Edit a single video using transcript text edits',
 			configureEditVideoCommand as CommandBuilder,
-			handleEditVideoCommand as CommandHandler,
+			createEditVideoHandler(handlerOptions) as CommandHandler,
 		)
 		.command(
 			'combine',
 			'Combine two videos with speech-aligned padding',
 			configureCombineVideosCommand as CommandBuilder,
-			handleCombineVideosCommand as CommandHandler,
+			createCombineVideosHandler(handlerOptions) as CommandHandler,
 		)
 		.command(
 			'app start',
@@ -77,7 +119,7 @@ async function main() {
 			},
 		)
 		.command(
-			'transcribe <input>',
+			'transcribe [input]',
 			'Transcribe a single audio/video file',
 			(command) =>
 				command
@@ -108,31 +150,33 @@ async function main() {
 						describe: 'Output base path (without extension)',
 					}),
 			async (argv) => {
-				const inputPath = path.resolve(String(argv.input))
-				const outputBasePath =
-					resolveOptionalString(argv['output-base']) ??
-					path.join(
-						path.dirname(inputPath),
-						`${path.parse(inputPath).name}-transcript`,
-					)
-				const threads =
-					typeof argv.threads === 'number' && Number.isFinite(argv.threads)
-						? argv.threads
-						: undefined
-				const result = await transcribeAudio(inputPath, {
-					modelPath: resolveOptionalString(argv['model-path']),
-					language: resolveOptionalString(argv.language),
-					threads,
-					binaryPath: resolveOptionalString(argv['binary-path']),
-					outputBasePath,
-				})
-				console.log(`Transcript written to ${outputBasePath}.txt`)
-				console.log(`Segments written to ${outputBasePath}.json`)
-				console.log(result.text)
+				const transcribeArgs = await resolveTranscribeArgs(argv, context)
+				let resultText = ''
+				await withSpinner(
+					'Transcribing audio',
+					async () => {
+						const result = await transcribeAudio(transcribeArgs.inputPath, {
+							modelPath: transcribeArgs.modelPath,
+							language: transcribeArgs.language,
+							threads: transcribeArgs.threads,
+							binaryPath: transcribeArgs.binaryPath,
+							outputBasePath: transcribeArgs.outputBasePath,
+						})
+						resultText = result.text
+					},
+					{ successText: 'Transcription complete', enabled: context.interactive },
+				)
+				console.log(
+					`Transcript written to ${transcribeArgs.outputBasePath}.txt`,
+				)
+				console.log(
+					`Segments written to ${transcribeArgs.outputBasePath}.json`,
+				)
+				console.log(resultText)
 			},
 		)
 		.command(
-			'detect-speech <input>',
+			'detect-speech [input]',
 			'Show detected speech segments for a file',
 			(command) =>
 				command
@@ -149,12 +193,23 @@ async function main() {
 						describe: 'End time in seconds',
 					}),
 			async (argv) => {
-				await ensureFfmpegAvailable()
-				const segments = await detectSpeechSegmentsForFile({
-					inputPath: String(argv.input),
-					start: typeof argv.start === 'number' ? argv.start : undefined,
-					end: typeof argv.end === 'number' ? argv.end : undefined,
-				})
+				const { inputPath, start, end } = await resolveDetectSpeechArgs(
+					argv,
+					context,
+				)
+				let segments: unknown = []
+				await withSpinner(
+					'Detecting speech',
+					async () => {
+						await ensureFfmpegAvailable()
+						segments = await detectSpeechSegmentsForFile({
+							inputPath,
+							start,
+							end,
+						})
+					},
+					{ successText: 'Speech detection complete', enabled: context.interactive },
+				)
 				console.log(JSON.stringify(segments, null, 2))
 			},
 		)
@@ -165,7 +220,185 @@ async function main() {
 	await parser.parseAsync()
 }
 
+function createCliUxContext(): CliUxContext {
+	const interactive = isInteractive()
+	if (!interactive) {
+		return { interactive }
+	}
+	const prompter = createInquirerPrompter()
+	const pathPicker = createPathPicker(prompter)
+	return { interactive, prompter, pathPicker }
+}
+
+async function promptForCommand(
+	prompter: Prompter,
+): Promise<string[] | null> {
+	const selection = await prompter.select('Choose a command', [
+		{
+			name: 'Process chapters into separate files',
+			value: 'process',
+		},
+		{
+			name: 'Edit a single video using transcript text edits',
+			value: 'edit',
+		},
+		{
+			name: 'Combine two videos with speech-aligned padding',
+			value: 'combine',
+		},
+		{
+			name: 'Start the web UI server',
+			value: 'app-start',
+		},
+		{
+			name: 'Transcribe a single audio/video file',
+			value: 'transcribe',
+		},
+		{
+			name: 'Show detected speech segments for a file',
+			value: 'detect-speech',
+		},
+		{ name: 'Show help', value: 'help' },
+		{ name: 'Exit', value: 'exit' },
+	])
+	switch (selection) {
+		case 'exit':
+			return null
+		case 'help':
+			return ['--help']
+		case 'app-start':
+			return ['app', 'start']
+		default:
+			return [selection]
+	}
+}
+
+async function resolveProcessArgs(argv: Arguments, context: CliUxContext) {
+	let inputPaths = collectStringArray(argv.input)
+	if (inputPaths.length === 0) {
+		if (!context.interactive || !context.pathPicker || !context.prompter) {
+			throw new Error('At least one input file is required.')
+		}
+		inputPaths = await promptForInputFiles(context)
+	}
+
+	let outputDir = resolveOptionalString(argv['output-dir'])
+	if (!outputDir && context.interactive && context.prompter && context.pathPicker) {
+		const chooseOutput = await context.prompter.confirm(
+			'Choose a custom output directory?',
+			{ defaultValue: false },
+		)
+		if (chooseOutput) {
+			outputDir = await context.pathPicker.pickExistingDirectory({
+				message: 'Select output directory',
+			})
+		}
+	}
+
+	const updatedArgs = {
+		...argv,
+		input: inputPaths,
+		'output-dir': outputDir ?? argv['output-dir'],
+	} as Arguments
+	return normalizeProcessArgs(updatedArgs)
+}
+
+async function promptForInputFiles(context: CliUxContext) {
+	if (!context.prompter || !context.pathPicker) {
+		throw new Error('Interactive prompts are not available.')
+	}
+	const inputPaths: string[] = []
+	let addAnother = true
+	while (addAnother) {
+		const inputPath = await context.pathPicker.pickExistingFile({
+			message:
+				inputPaths.length === 0
+					? 'Select input video file'
+					: 'Select another input video file',
+			extensions: VIDEO_EXTENSIONS,
+		})
+		inputPaths.push(inputPath)
+		addAnother = await context.prompter.confirm('Add another input file?', {
+			defaultValue: false,
+		})
+	}
+	return inputPaths
+}
+
+async function resolveTranscribeArgs(argv: Arguments, context: CliUxContext) {
+	let input = resolveOptionalString(argv.input)
+	if (!input) {
+		if (!context.interactive || !context.pathPicker) {
+			throw new Error('Input audio/video file is required.')
+		}
+		input = await context.pathPicker.pickExistingFile({
+			message: 'Select input audio/video file',
+		})
+	}
+	const inputPath = path.resolve(input)
+	const outputBasePath =
+		resolveOptionalString(argv['output-base']) ??
+		buildTranscribeOutputBase(inputPath)
+	const threads = resolveOptionalNumber(argv.threads)
+	return {
+		inputPath,
+		outputBasePath,
+		threads,
+		modelPath: resolveOptionalString(argv['model-path']),
+		language: resolveOptionalString(argv.language),
+		binaryPath: resolveOptionalString(argv['binary-path']),
+	}
+}
+
+async function resolveDetectSpeechArgs(argv: Arguments, context: CliUxContext) {
+	let input = resolveOptionalString(argv.input)
+	if (!input) {
+		if (!context.interactive || !context.pathPicker) {
+			throw new Error('Input audio/video file is required.')
+		}
+		input = await context.pathPicker.pickExistingFile({
+			message: 'Select input audio/video file',
+		})
+	}
+	return {
+		inputPath: String(input),
+		start: resolveOptionalNumber(argv.start),
+		end: resolveOptionalNumber(argv.end),
+	}
+}
+
+function buildTranscribeOutputBase(inputPath: string) {
+	return path.join(
+		path.dirname(inputPath),
+		`${path.parse(inputPath).name}-transcript`,
+	)
+}
+
+function collectStringArray(value: unknown) {
+	if (Array.isArray(value)) {
+		return value.filter(
+			(entry): entry is string =>
+				typeof entry === 'string' && entry.trim().length > 0,
+		)
+	}
+	if (typeof value === 'string' && value.trim().length > 0) {
+		return [value]
+	}
+	return []
+}
+
+function resolveOptionalNumber(value: unknown) {
+	if (typeof value !== 'number' || !Number.isFinite(value)) {
+		return undefined
+	}
+	return value
+}
+
 main().catch((error) => {
+	if (error instanceof PromptCancelled) {
+		console.log('[info] Cancelled.')
+		return
+	}
 	console.error(
 		`[error] ${error instanceof Error ? error.message : String(error)}`,
 	)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eprec",
   "type": "module",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -11,7 +11,7 @@
     "app:start": "bun ./app-server.ts",
     "format": "prettier --write .",
     "test": "bun test process-course utils.test.ts",
-    "test:e2e": "bun test e2e",
+    "test:e2e": "bun test ./e2e",
     "test:smoke": "bunx playwright test -c playwright-smoke-config.ts",
     "test:all": "bun test '**/*.test.ts'",
     "validate": "bun run test"
@@ -44,7 +44,9 @@
   },
   "dependencies": {
     "get-port": "^7.1.0",
+    "inquirer": "^13.2.1",
     "onnxruntime-node": "^1.23.2",
+    "ora": "^9.1.0",
     "remix": "3.0.0-alpha.0",
     "yargs": "^18.0.0"
   }

package/process-course/cli.ts

@@ -8,6 +8,16 @@ import { normalizeSkipPhrases } from './utils/transcript'
 import { parseChapterSelection } from './utils/chapter-selection'
 import type { ChapterSelection } from './types'
 
+export const VIDEO_EXTENSIONS = [
+	'.mp4',
+	'.mkv',
+	'.avi',
+	'.mov',
+	'.webm',
+	'.flv',
+	'.m4v',
+]
+
 export interface CliArgs {
 	inputPaths: string[]
 	outputDir: string | null
@@ -118,16 +128,7 @@ export function normalizeProcessArgs(
 	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) =>
+			const hasVideoExtension = VIDEO_EXTENSIONS.some((ext) =>
 				outputCandidate.toLowerCase().endsWith(ext),
 			)
 

package/process-course/edits/cli-prompts.test.ts

@@ -0,0 +1,108 @@
+import { test, expect } from 'bun:test'
+import type { Arguments } from 'yargs'
+import {
+	resolveEditVideoArgs,
+	resolveCombineVideosArgs,
+	buildCombinedOutputPath,
+} from './cli'
+import { buildEditedOutputPath } from './video-editor'
+import type { PathPicker } from '../../cli-ux'
+
+function createArgs(values: Record<string, unknown>): Arguments {
+	return values as Arguments
+}
+
+function createPathPicker(options?: {
+	files?: string[]
+	outputs?: string[]
+	directories?: string[]
+}): PathPicker {
+	const fileResponses = options?.files ?? []
+	const outputResponses = options?.outputs ?? []
+	const directoryResponses = options?.directories ?? []
+	let fileIndex = 0
+	let outputIndex = 0
+	let directoryIndex = 0
+
+	return {
+		async pickExistingFile() {
+			const response = fileResponses[fileIndex]
+			fileIndex += 1
+			if (!response) {
+				throw new Error('Missing file response')
+			}
+			return response
+		},
+		async pickExistingDirectory() {
+			const response = directoryResponses[directoryIndex]
+			directoryIndex += 1
+			if (!response) {
+				throw new Error('Missing directory response')
+			}
+			return response
+		},
+		async pickOutputPath({ defaultPath }) {
+			const response = outputResponses[outputIndex] ?? defaultPath
+			outputIndex += 1
+			if (!response) {
+				throw new Error('Missing output response')
+			}
+			return response
+		},
+	}
+}
+
+test('resolveEditVideoArgs prompts for missing required paths', async () => {
+	const args = createArgs({})
+	const pathPicker = createPathPicker({
+		files: ['input.mp4', 'transcript.json', 'edited.txt'],
+	})
+	const result = await resolveEditVideoArgs(args, {
+		interactive: true,
+		pathPicker,
+	})
+
+	expect(result).toEqual({
+		input: 'input.mp4',
+		transcript: 'transcript.json',
+		edited: 'edited.txt',
+		output: buildEditedOutputPath('input.mp4'),
+		'padding-ms': undefined,
+	})
+})
+
+test('resolveCombineVideosArgs prompts for transcript when edited provided', async () => {
+	const args = createArgs({
+		video1: 'video1.mp4',
+		edited1: 'edited1.txt',
+		video2: 'video2.mp4',
+		output: 'combined.mp4',
+	})
+	const pathPicker = createPathPicker({
+		files: ['transcript1.json'],
+	})
+	const result = await resolveCombineVideosArgs(args, {
+		interactive: true,
+		pathPicker,
+	})
+
+	expect(result.transcript1).toBe('transcript1.json')
+	expect(result.transcript2).toBeUndefined()
+	expect(result.output).toBe('combined.mp4')
+})
+
+test('resolveCombineVideosArgs uses default output when missing', async () => {
+	const args = createArgs({
+		video1: 'video1.mov',
+		video2: 'video2.mp4',
+	})
+	const pathPicker = createPathPicker()
+	const result = await resolveCombineVideosArgs(args, {
+		interactive: true,
+		pathPicker,
+	})
+
+	expect(result.output).toBe(
+		buildCombinedOutputPath('video1.mov', 'video2.mp4'),
+	)
+})

package/process-course/edits/cli.ts

@@ -1,7 +1,18 @@
 #!/usr/bin/env bun
+import path from 'node:path'
 import type { Argv, Arguments, CommandBuilder, CommandHandler } from 'yargs'
 import yargs from 'yargs/yargs'
 import { hideBin } from 'yargs/helpers'
+import {
+	PromptCancelled,
+	createInquirerPrompter,
+	createPathPicker,
+	isInteractive,
+	resolveOptionalString,
+	type PathPicker,
+	type Prompter,
+	withSpinner,
+} from '../../cli-ux'
 import { editVideo, buildEditedOutputPath } from './video-editor'
 import { combineVideos } from './combined-video-editor'
 
@@ -24,21 +35,205 @@ export type CombineVideosCommandArgs = {
 	'padding-ms'?: number
 }
 
+type CliUxOptions = {
+	interactive: boolean
+	pathPicker?: PathPicker
+}
+
+export function buildCombinedOutputPath(video1Path: string, video2Path: string) {
+	const dir = path.dirname(video1Path)
+	const ext = path.extname(video1Path) || path.extname(video2Path) || '.mp4'
+	const name1 = path.parse(video1Path).name
+	const name2 = path.parse(video2Path).name
+	return path.join(dir, `combined-${name1}-${name2}${ext}`)
+}
+
+export async function resolveEditVideoArgs(
+	argv: Arguments,
+	options: CliUxOptions,
+): Promise<EditVideoCommandArgs> {
+	const pathPicker = options.pathPicker
+	let input = resolveOptionalString(argv.input)
+	if (!input) {
+		if (!options.interactive || !pathPicker) {
+			throw new Error('Input video path is required.')
+		}
+		input = await pathPicker.pickExistingFile({
+			message: 'Select input video file',
+		})
+	}
+	let transcript = resolveOptionalString(argv.transcript)
+	if (!transcript) {
+		if (!options.interactive || !pathPicker) {
+			throw new Error('Transcript JSON path is required.')
+		}
+		transcript = await pathPicker.pickExistingFile({
+			message: 'Select transcript JSON file',
+		})
+	}
+	let edited = resolveOptionalString(argv.edited)
+	if (!edited) {
+		if (!options.interactive || !pathPicker) {
+			throw new Error('Edited transcript path is required.')
+		}
+		edited = await pathPicker.pickExistingFile({
+			message: 'Select edited transcript text file',
+		})
+	}
+	const defaultOutputPath = buildEditedOutputPath(input)
+	const outputPath =
+		resolveOptionalString(argv.output) ?? defaultOutputPath
+	const paddingMs = resolvePaddingMs(argv['padding-ms'])
+
+	return {
+		input,
+		transcript,
+		edited,
+		output: outputPath,
+		'padding-ms': paddingMs,
+	}
+}
+
+export async function resolveCombineVideosArgs(
+	argv: Arguments,
+	options: CliUxOptions,
+): Promise<CombineVideosCommandArgs> {
+	const pathPicker = options.pathPicker
+	let video1 = resolveOptionalString(argv.video1)
+	if (!video1) {
+		if (!options.interactive || !pathPicker) {
+			throw new Error('First video path is required.')
+		}
+		video1 = await pathPicker.pickExistingFile({
+			message: 'Select first video',
+		})
+	}
+	let video2 = resolveOptionalString(argv.video2)
+	if (!video2) {
+		if (!options.interactive || !pathPicker) {
+			throw new Error('Second video path is required.')
+		}
+		video2 = await pathPicker.pickExistingFile({
+			message: 'Select second video',
+		})
+	}
+	let transcript1 = resolveOptionalString(argv.transcript1)
+	let transcript2 = resolveOptionalString(argv.transcript2)
+	const edited1 = resolveOptionalString(argv.edited1)
+	const edited2 = resolveOptionalString(argv.edited2)
+
+	if (edited1 && !transcript1) {
+		if (!options.interactive || !pathPicker) {
+			throw new Error('Transcript JSON is required for edited1.')
+		}
+		transcript1 = await pathPicker.pickExistingFile({
+			message: 'Select transcript JSON for first video',
+		})
+	}
+	if (edited2 && !transcript2) {
+		if (!options.interactive || !pathPicker) {
+			throw new Error('Transcript JSON is required for edited2.')
+		}
+		transcript2 = await pathPicker.pickExistingFile({
+			message: 'Select transcript JSON for second video',
+		})
+	}
+
+	let output = resolveOptionalString(argv.output)
+	if (!output) {
+		if (options.interactive && pathPicker) {
+			output = await pathPicker.pickOutputPath({
+				message: 'Select output video path',
+				defaultPath: buildCombinedOutputPath(video1, video2),
+			})
+		} else {
+			output = buildCombinedOutputPath(video1, video2)
+		}
+	}
+	const paddingMs = resolvePaddingMs(argv['padding-ms'])
+
+	return {
+		video1,
+		transcript1,
+		edited1,
+		video2,
+		transcript2,
+		edited2,
+		output,
+		'padding-ms': paddingMs,
+	}
+}
+
+function resolvePaddingMs(value: unknown) {
+	if (typeof value !== 'number' || !Number.isFinite(value)) {
+		return undefined
+	}
+	return value
+}
+
+export function createEditVideoHandler(options: CliUxOptions): CommandHandler {
+	return async (argv) => {
+		const args = await resolveEditVideoArgs(argv, options)
+		await withSpinner(
+			'Editing video',
+			async () => {
+				const result = await editVideo({
+					inputPath: String(args.input),
+					transcriptJsonPath: String(args.transcript),
+					editedTextPath: String(args.edited),
+					outputPath: String(args.output),
+					paddingMs: args['padding-ms'],
+				})
+				if (!result.success) {
+					throw new Error(result.error ?? 'Edit failed.')
+				}
+			},
+			{ successText: 'Edit complete' },
+		)
+		console.log(`Edited video written to ${args.output}`)
+	}
+}
+
+export function createCombineVideosHandler(options: CliUxOptions): CommandHandler {
+	return async (argv) => {
+		const args = await resolveCombineVideosArgs(argv, options)
+		let outputPath = ''
+		await withSpinner(
+			'Combining videos',
+			async () => {
+				const result = await combineVideos({
+					video1Path: String(args.video1),
+					video1TranscriptJsonPath: args.transcript1,
+					video1EditedTextPath: args.edited1,
+					video2Path: String(args.video2),
+					video2TranscriptJsonPath: args.transcript2,
+					video2EditedTextPath: args.edited2,
+					outputPath: String(args.output),
+					overlapPaddingMs: args['padding-ms'],
+				})
+				if (!result.success) {
+					throw new Error(result.error ?? 'Combine failed.')
+				}
+				outputPath = result.outputPath
+			},
+			{ successText: 'Combine complete' },
+		)
+		console.log(`Combined video written to ${outputPath}`)
+	}
+}
+
 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', {
@@ -52,31 +247,14 @@ export function configureEditVideoCommand(command: Argv) {
 }
 
 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}`)
+	const options = createDefaultCliUxOptions()
+	await createEditVideoHandler(options)(argv)
 }
 
 export function configureCombineVideosCommand(command: Argv) {
 	return command
 		.option('video1', {
 			type: 'string',
-			demandOption: true,
 			describe: 'First video path',
 		})
 		.option('transcript1', {
@@ -89,7 +267,6 @@ export function configureCombineVideosCommand(command: Argv) {
 		})
 		.option('video2', {
 			type: 'string',
-			demandOption: true,
 			describe: 'Second video path',
 		})
 		.option('transcript2', {
@@ -102,7 +279,6 @@ export function configureCombineVideosCommand(command: Argv) {
 		})
 		.option('output', {
 			type: 'string',
-			demandOption: true,
 			describe: 'Output video path',
 		})
 		.option('padding-ms', {
@@ -112,43 +288,47 @@ export function configureCombineVideosCommand(command: Argv) {
 }
 
 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)
+	const options = createDefaultCliUxOptions()
+	await createCombineVideosHandler(options)(argv)
+}
+
+function createDefaultCliUxOptions(): CliUxOptions {
+	const interactive = isInteractive()
+	if (!interactive) {
+		return { interactive }
 	}
-	console.log(`Combined video written to ${result.outputPath}`)
+	const prompter = createInquirerPrompter()
+	return { interactive, pathPicker: createPathPicker(prompter) }
 }
 
-export async function runEditsCli() {
-	const parser = yargs(hideBin(process.argv))
+export async function runEditsCli(rawArgs = hideBin(process.argv)) {
+	const interactive = isInteractive()
+	const prompter = interactive ? createInquirerPrompter() : null
+	const pathPicker = prompter ? createPathPicker(prompter) : undefined
+	let args = rawArgs
+
+	if (interactive && args.length === 0 && prompter) {
+		const selection = await promptForEditsCommand(prompter)
+		if (!selection) {
+			return
+		}
+		args = selection
+	}
+
+	const handlerOptions: CliUxOptions = { interactive, pathPicker }
+	const parser = yargs(args)
 		.scriptName('video-edits')
 		.command(
 			'edit-video',
 			'Edit a single video using transcript text edits',
 			configureEditVideoCommand as CommandBuilder,
-			handleEditVideoCommand as CommandHandler,
+			createEditVideoHandler(handlerOptions),
 		)
 		.command(
 			'combine-videos',
 			'Combine two videos with speech-aligned padding',
 			configureCombineVideosCommand as CommandBuilder,
-			handleCombineVideosCommand as CommandHandler,
+			createCombineVideosHandler(handlerOptions),
 		)
 		.demandCommand(1)
 		.strict()
@@ -159,9 +339,37 @@ export async function runEditsCli() {
 
 if (import.meta.main) {
 	runEditsCli().catch((error) => {
+		if (error instanceof PromptCancelled) {
+			console.log('[info] Cancelled.')
+			return
+		}
 		console.error(
 			`[error] ${error instanceof Error ? error.message : String(error)}`,
 		)
 		process.exit(1)
 	})
 }
+
+async function promptForEditsCommand(
+	prompter: Prompter,
+): Promise<string[] | null> {
+	const selection = await prompter.select('Choose a command', [
+		{
+			name: 'Edit a single video using transcript text edits',
+			value: 'edit-video',
+		},
+		{
+			name: 'Combine two videos with speech-aligned padding',
+			value: 'combine-videos',
+		},
+		{ name: 'Show help', value: 'help' },
+		{ name: 'Exit', value: 'exit' },
+	])
+	if (selection === 'exit') {
+		return null
+	}
+	if (selection === 'help') {
+		return ['--help']
+	}
+	return [selection]
+}

package/process-course/logging.ts

@@ -1,16 +1,41 @@
 import { formatCommand } from '../utils'
 import { buildChapterLogPath } from './paths'
 
+type LogHook = () => void
+
+let beforeLogHook: LogHook | null = null
+let afterLogHook: LogHook | null = null
+
+export function setLogHooks(hooks: {
+	beforeLog?: LogHook
+	afterLog?: LogHook
+}) {
+	beforeLogHook = hooks.beforeLog ?? null
+	afterLogHook = hooks.afterLog ?? null
+}
+
+function withLogHooks(callback: () => void) {
+	beforeLogHook?.()
+	callback()
+	afterLogHook?.()
+}
+
 export function logCommand(command: string[]) {
-	console.log(`[cmd] ${formatCommand(command)}`)
+	withLogHooks(() => {
+		console.log(`[cmd] ${formatCommand(command)}`)
+	})
 }
 
 export function logInfo(message: string) {
-	console.log(`[info] ${message}`)
+	withLogHooks(() => {
+		console.log(`[info] ${message}`)
+	})
 }
 
 export function logWarn(message: string) {
-	console.warn(`[warn] ${message}`)
+	withLogHooks(() => {
+		console.warn(`[warn] ${message}`)
+	})
 }
 
 export async function writeChapterLog(