eprec 1.2.0 → 1.4.0

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,209 @@ 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 +251,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 +271,6 @@ export function configureCombineVideosCommand(command: Argv) {
 		})
 		.option('video2', {
 			type: 'string',
-			demandOption: true,
 			describe: 'Second video path',
 		})
 		.option('transcript2', {
@@ -102,7 +283,6 @@ export function configureCombineVideosCommand(command: Argv) {
 		})
 		.option('output', {
 			type: 'string',
-			demandOption: true,
 			describe: 'Output video path',
 		})
 		.option('padding-ms', {
@@ -112,43 +292,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 +343,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(