eprec 1.2.0 → 1.4.0

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,34 @@ 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 +194,26 @@ 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 +224,188 @@ 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,17 +1,17 @@
 {
   "name": "eprec",
   "type": "module",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/epicweb-dev/eprec"
   },
   "scripts": {
-    "app:start": "bun ./app-server.ts",
+    "app:start": "bun --watch ./cli.ts app start",
     "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'),
+	)
+})