eprec 0.0.1 → 1.1.0

package/app-server.ts

@@ -0,0 +1,60 @@
+import './app/config/init-env.ts'
+
+import getPort from 'get-port'
+import { getEnv } from './app/config/env.ts'
+import { createAppRouter } from './app/router.tsx'
+import { createBundlingRoutes } from './server/bundling.ts'
+
+type AppServerOptions = {
+	host?: string
+	port?: number
+}
+
+function startServer(port: number, hostname: string) {
+	const router = createAppRouter(import.meta.dirname)
+	return Bun.serve({
+		port,
+		hostname,
+		idleTimeout: 30,
+		routes: createBundlingRoutes(import.meta.dirname),
+		async fetch(request) {
+			try {
+				return await router.fetch(request)
+			} catch (error) {
+				console.error(error)
+				return new Response('Internal Server Error', { status: 500 })
+			}
+		},
+	})
+}
+
+async function getServerPort(nodeEnv: string, desiredPort: number) {
+	if (nodeEnv === 'production') {
+		return desiredPort
+	}
+	const port = await getPort({ port: desiredPort })
+	if (port !== desiredPort) {
+		console.warn(`⚠️  Port ${desiredPort} was taken, using port ${port} instead`)
+	}
+	return port
+}
+
+export async function startAppServer(options: AppServerOptions = {}) {
+	const env = getEnv()
+	const host = options.host ?? env.HOST
+	const desiredPort = options.port ?? env.PORT
+	const port = await getServerPort(env.NODE_ENV, desiredPort)
+	const server = startServer(port, host)
+	const hostname = server.hostname.includes(':')
+		? `[${server.hostname}]`
+		: server.hostname
+	const url = `http://${hostname}:${server.port}`
+
+	console.log(`[app] running at ${url}`)
+
+	return { server, url }
+}
+
+if (import.meta.main) {
+	await startAppServer()
+}

package/cli.ts

@@ -0,0 +1,173 @@
+#!/usr/bin/env bun
+import path from 'node:path'
+import type { CommandBuilder, CommandHandler } from 'yargs'
+import yargs from 'yargs/yargs'
+import { hideBin } from 'yargs/helpers'
+import { startAppServer } from './app-server'
+import { ensureFfmpegAvailable } from './process-course/ffmpeg'
+import {
+	normalizeProcessArgs,
+	configureProcessCommand,
+} from './process-course/cli'
+import { runProcessCourse } from './process-course-video'
+import {
+	configureEditVideoCommand,
+	configureCombineVideosCommand,
+	handleCombineVideosCommand,
+	handleEditVideoCommand,
+} from './process-course/edits/cli'
+import { detectSpeechSegmentsForFile } from './speech-detection'
+import {
+	getDefaultWhisperModelPath,
+	transcribeAudio,
+} from './whispercpp-transcribe'
+
+function resolveOptionalString(value: unknown) {
+	if (typeof value !== 'string') {
+		return undefined
+	}
+	const trimmed = value.trim()
+	return trimmed.length > 0 ? trimmed : undefined
+}
+
+async function main() {
+	const parser = yargs(hideBin(process.argv))
+		.scriptName('eprec')
+		.command(
+			'process <input...>',
+			'Process chapters into separate files',
+			configureProcessCommand,
+			async (argv) => {
+				const args = normalizeProcessArgs(argv)
+				await runProcessCourse(args)
+			},
+		)
+		.command(
+			'edit',
+			'Edit a single video using transcript text edits',
+			configureEditVideoCommand as CommandBuilder,
+			handleEditVideoCommand as CommandHandler,
+		)
+		.command(
+			'combine',
+			'Combine two videos with speech-aligned padding',
+			configureCombineVideosCommand as CommandBuilder,
+			handleCombineVideosCommand as CommandHandler,
+		)
+		.command(
+			'app start',
+			'Start the web UI server',
+			(command) =>
+				command
+					.option('port', {
+						type: 'number',
+						describe: 'Port for the app server',
+					})
+					.option('host', {
+						type: 'string',
+						describe: 'Host to bind for the app server',
+					}),
+			async (argv) => {
+				const port =
+					typeof argv.port === 'number' && Number.isFinite(argv.port)
+						? argv.port
+						: undefined
+				const host = resolveOptionalString(argv.host)
+				await startAppServer({ port, host })
+			},
+		)
+		.command(
+			'transcribe <input>',
+			'Transcribe a single audio/video file',
+			(command) =>
+				command
+					.positional('input', {
+						type: 'string',
+						describe: 'Input audio/video file',
+					})
+					.option('model-path', {
+						type: 'string',
+						describe: 'Path to whisper.cpp model file',
+						default: getDefaultWhisperModelPath(),
+					})
+					.option('language', {
+						type: 'string',
+						describe: 'Language passed to whisper.cpp',
+						default: 'en',
+					})
+					.option('threads', {
+						type: 'number',
+						describe: 'Thread count for whisper.cpp',
+					})
+					.option('binary-path', {
+						type: 'string',
+						describe: 'Path to whisper.cpp CLI (whisper-cli)',
+					})
+					.option('output-base', {
+						type: 'string',
+						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)
+			},
+		)
+		.command(
+			'detect-speech <input>',
+			'Show detected speech segments for a file',
+			(command) =>
+				command
+					.positional('input', {
+						type: 'string',
+						describe: 'Input audio/video file',
+					})
+					.option('start', {
+						type: 'number',
+						describe: 'Start time in seconds',
+					})
+					.option('end', {
+						type: 'number',
+						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,
+				})
+				console.log(JSON.stringify(segments, null, 2))
+			},
+		)
+		.demandCommand(1)
+		.strict()
+		.help()
+
+	await parser.parseAsync()
+}
+
+main().catch((error) => {
+	console.error(
+		`[error] ${error instanceof Error ? error.message : String(error)}`,
+	)
+	process.exit(1)
+})

package/package.json

@@ -1,10 +1,49 @@
 {
   "name": "eprec",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for eprec",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+  "type": "module",
+  "version": "1.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/epicweb-dev/eprec"
+  },
+  "scripts": {
+    "app:start": "bun ./app-server.ts",
+    "format": "prettier --write .",
+    "test": "bun test process-course utils.test.ts",
+    "test:e2e": "bun test e2e",
+    "test:all": "bun test",
+    "validate": "bun run test"
+  },
+  "bin": {
+    "eprec": "./cli.ts"
+  },
+  "files": [
+    "app/**",
+    "app-server.ts",
+    "cli.ts",
+    "process-course/**",
+    "process-course-video.ts",
+    "public/**",
+    "server/**",
+    "speech-detection.ts",
+    "utils.ts",
+    "whispercpp-transcribe.ts"
+  ],
+  "prettier": "@epic-web/config/prettier",
+  "devDependencies": {
+    "@epic-web/config": "^1.21.3",
+    "@types/bun": "latest",
+    "@types/yargs": "^17.0.35",
+    "prettier": "^3.8.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "get-port": "^7.1.0",
+    "onnxruntime-node": "^1.23.2",
+    "remix": "3.0.0-alpha.0",
+    "yargs": "^18.0.0"
+  }
 }