commit c0f6c37536d0fe28ff66711fc1530b4a9f257645 · dunkirk.sh/thistle

+157 -1

src/index.ts

···

       92
       92
        
       	WhisperServiceManager,

     

       93
       93
        
       } from "./lib/transcription";

     

       94
       94
        
       import {

     

       95
       95
       +
       	extractAudioCreationDate,

     

       96
       96
       +
       	findMatchingMeetingTime,

     

       97
       97
       +
       	getDayName,

     

       98
       98
       +
       } from "./lib/audio-metadata";

     

       99
       99
       +
       import {

     

       95
       100
        
       	validateClassId,

     

       96
       101
        
       	validateCourseCode,

     

       97
       102
        
       	validateCourseName,

     
···

       2082
       2087
        
       				}

     

       2083
       2088
        
       			},

     

       2084
       2089
        
       		},

     

       2090
       2090
       +
       		"/api/transcriptions/detect-meeting-time": {

     

       2091
       2091
       +
       			POST: async (req) => {

     

       2092
       2092
       +
       				try {

     

       2093
       2093
       +
       					const user = requireAuth(req);

     

       2094
       2094
       +
       

     

       2095
       2095
       +
       					const formData = await req.formData();

     

       2096
       2096
       +
       					const file = formData.get("audio") as File;

     

       2097
       2097
       +
       					const classId = formData.get("class_id") as string | null;

     

       2098
       2098
       +
       					const fileTimestampStr = formData.get("file_timestamp") as

     

       2099
       2099
       +
       						| string

     

       2100
       2100
       +
       						| null;

     

       2101
       2101
       +
       

     

       2102
       2102
       +
       					if (!file) throw ValidationErrors.missingField("audio");

     

       2103
       2103
       +
       					if (!classId) throw ValidationErrors.missingField("class_id");

     

       2104
       2104
       +
       

     

       2105
       2105
       +
       					// Verify user is enrolled in the class

     

       2106
       2106
       +
       					const enrolled = isUserEnrolledInClass(user.id, classId);

     

       2107
       2107
       +
       					if (!enrolled && user.role !== "admin") {

     

       2108
       2108
       +
       						return Response.json(

     

       2109
       2109
       +
       							{ error: "Not enrolled in this class" },

     

       2110
       2110
       +
       							{ status: 403 },

     

       2111
       2111
       +
       						);

     

       2112
       2112
       +
       					}

     

       2113
       2113
       +
       

     

       2114
       2114
       +
       					let creationDate: Date | null = null;

     

       2115
       2115
       +
       

     

       2116
       2116
       +
       					// Try client-provided timestamp first (most accurate - from original file)

     

       2117
       2117
       +
       					if (fileTimestampStr) {

     

       2118
       2118
       +
       						const timestamp = Number.parseInt(fileTimestampStr, 10);

     

       2119
       2119
       +
       						if (!Number.isNaN(timestamp)) {

     

       2120
       2120
       +
       							creationDate = new Date(timestamp);

     

       2121
       2121
       +
       							console.log(

     

       2122
       2122
       +
       								`[Upload] Using client-provided file timestamp: ${creationDate.toISOString()}`,

     

       2123
       2123
       +
       							);

     

       2124
       2124
       +
       						}

     

       2125
       2125
       +
       					}

     

       2126
       2126
       +
       

     

       2127
       2127
       +
       					// Fallback: extract from audio file metadata

     

       2128
       2128
       +
       					if (!creationDate) {

     

       2129
       2129
       +
       						// Save file temporarily

     

       2130
       2130
       +
       						const tempId = crypto.randomUUID();

     

       2131
       2131
       +
       						const fileExtension = file.name.split(".").pop()?.toLowerCase();

     

       2132
       2132
       +
       						const tempFilename = `temp-${tempId}.${fileExtension}`;

     

       2133
       2133
       +
       						const tempPath = `./uploads/${tempFilename}`;

     

       2134
       2134
       +
       

     

       2135
       2135
       +
       						await Bun.write(tempPath, file);

     

       2136
       2136
       +
       

     

       2137
       2137
       +
       						try {

     

       2138
       2138
       +
       							creationDate = await extractAudioCreationDate(tempPath);

     

       2139
       2139
       +
       						} finally {

     

       2140
       2140
       +
       							// Clean up temp file

     

       2141
       2141
       +
       							try {

     

       2142
       2142
       +
       								await Bun.$`rm ${tempPath}`.quiet();

     

       2143
       2143
       +
       							} catch {

     

       2144
       2144
       +
       								// Ignore cleanup errors

     

       2145
       2145
       +
       							}

     

       2146
       2146
       +
       						}

     

       2147
       2147
       +
       					}

     

       2148
       2148
       +
       

     

       2149
       2149
       +
       					if (!creationDate) {

     

       2150
       2150
       +
       						return Response.json({

     

       2151
       2151
       +
       							detected: false,

     

       2152
       2152
       +
       							meeting_time_id: null,

     

       2153
       2153
       +
       							message: "Could not extract creation date from audio file",

     

       2154
       2154
       +
       						});

     

       2155
       2155
       +
       					}

     

       2156
       2156
       +
       

     

       2157
       2157
       +
       					// Get meeting times for this class

     

       2158
       2158
       +
       					const meetingTimes = getMeetingTimesForClass(classId);

     

       2159
       2159
       +
       

     

       2160
       2160
       +
       					if (meetingTimes.length === 0) {

     

       2161
       2161
       +
       						return Response.json({

     

       2162
       2162
       +
       							detected: false,

     

       2163
       2163
       +
       							meeting_time_id: null,

     

       2164
       2164
       +
       							message: "No meeting times configured for this class",

     

       2165
       2165
       +
       						});

     

       2166
       2166
       +
       					}

     

       2167
       2167
       +
       

     

       2168
       2168
       +
       					// Find matching meeting time based on day of week

     

       2169
       2169
       +
       					const matchedId = findMatchingMeetingTime(

     

       2170
       2170
       +
       						creationDate,

     

       2171
       2171
       +
       						meetingTimes,

     

       2172
       2172
       +
       					);

     

       2173
       2173
       +
       

     

       2174
       2174
       +
       					if (matchedId) {

     

       2175
       2175
       +
       						const dayName = getDayName(creationDate);

     

       2176
       2176
       +
       						return Response.json({

     

       2177
       2177
       +
       							detected: true,

     

       2178
       2178
       +
       							meeting_time_id: matchedId,

     

       2179
       2179
       +
       							day: dayName,

     

       2180
       2180
       +
       							date: creationDate.toISOString(),

     

       2181
       2181
       +
       						});

     

       2182
       2182
       +
       					}

     

       2183
       2183
       +
       

     

       2184
       2184
       +
       					const dayName = getDayName(creationDate);

     

       2185
       2185
       +
       					return Response.json({

     

       2186
       2186
       +
       						detected: false,

     

       2187
       2187
       +
       						meeting_time_id: null,

     

       2188
       2188
       +
       						day: dayName,

     

       2189
       2189
       +
       						date: creationDate.toISOString(),

     

       2190
       2190
       +
       						message: `No meeting time matches ${dayName}`,

     

       2191
       2191
       +
       					});

     

       2192
       2192
       +
       				} catch (error) {

     

       2193
       2193
       +
       					return handleError(error);

     

       2194
       2194
       +
       				}

     

       2195
       2195
       +
       			},

     

       2196
       2196
       +
       		},

     

       2085
       2197
        
       		"/api/transcriptions": {

     

       2086
       2198
        
       			GET: async (req) => {

     

       2087
       2199
        
       				try {

     
···

       2294
       2406
        
       					const uploadDir = "./uploads";

     

       2295
       2407
        
       					await Bun.write(`${uploadDir}/${filename}`, file);

     

       2296
       2408
        
       

     

       2409
       2409
       +
       					// Auto-detect meeting time from audio metadata if class provided and no meeting_time_id

     

       2410
       2410
       +
       					let finalMeetingTimeId = meetingTimeId;

     

       2411
       2411
       +
       					if (classId && !meetingTimeId) {

     

       2412
       2412
       +
       						try {

     

       2413
       2413
       +
       							// Extract creation date from audio file

     

       2414
       2414
       +
       							const creationDate = await extractAudioCreationDate(

     

       2415
       2415
       +
       								`${uploadDir}/${filename}`,

     

       2416
       2416
       +
       							);

     

       2417
       2417
       +
       

     

       2418
       2418
       +
       							if (creationDate) {

     

       2419
       2419
       +
       								// Get meeting times for this class

     

       2420
       2420
       +
       								const meetingTimes = getMeetingTimesForClass(classId);

     

       2421
       2421
       +
       

     

       2422
       2422
       +
       								if (meetingTimes.length > 0) {

     

       2423
       2423
       +
       									// Find matching meeting time based on day of week

     

       2424
       2424
       +
       									const matchedId = findMatchingMeetingTime(

     

       2425
       2425
       +
       										creationDate,

     

       2426
       2426
       +
       										meetingTimes,

     

       2427
       2427
       +
       									);

     

       2428
       2428
       +
       

     

       2429
       2429
       +
       									if (matchedId) {

     

       2430
       2430
       +
       										finalMeetingTimeId = matchedId;

     

       2431
       2431
       +
       										const dayName = getDayName(creationDate);

     

       2432
       2432
       +
       										console.log(

     

       2433
       2433
       +
       											`[Upload] Auto-detected meeting time for ${dayName} (${creationDate.toISOString()}) -> ${matchedId}`,

     

       2434
       2434
       +
       										);

     

       2435
       2435
       +
       									} else {

     

       2436
       2436
       +
       										const dayName = getDayName(creationDate);

     

       2437
       2437
       +
       										console.log(

     

       2438
       2438
       +
       											`[Upload] No meeting time matches ${dayName}, leaving unassigned`,

     

       2439
       2439
       +
       										);

     

       2440
       2440
       +
       									}

     

       2441
       2441
       +
       								}

     

       2442
       2442
       +
       							}

     

       2443
       2443
       +
       						} catch (error) {

     

       2444
       2444
       +
       							// Non-fatal: just log and continue without auto-detection

     

       2445
       2445
       +
       							console.warn(

     

       2446
       2446
       +
       								"[Upload] Failed to auto-detect meeting time:",

     

       2447
       2447
       +
       								error instanceof Error ? error.message : "Unknown error",

     

       2448
       2448
       +
       							);

     

       2449
       2449
       +
       						}

     

       2450
       2450
       +
       					}

     

       2451
       2451
       +
       

     

       2297
       2452
        
       					// Create database record

     

       2298
       2453
        
       					db.run(

     

       2299
       2454
        
       						"INSERT INTO transcriptions (id, user_id, class_id, meeting_time_id, section_id, filename, original_filename, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",

     
···

       2301
       2456
        
       							transcriptionId,

     

       2302
       2457
        
       							user.id,

     

       2303
       2458
        
       							classId,

     

       2304
       2304
       -
       							meetingTimeId,

     

       2459
       2459
       +
       							finalMeetingTimeId,

     

       2305
       2460
        
       							sectionId,

     

       2306
       2461
        
       							filename,

     

       2307
       2462
        
       							file.name,

     
···

       2315
       2470
        
       					return Response.json(

     

       2316
       2471
        
       						{

     

       2317
       2472
        
       							id: transcriptionId,

     

       2473
       2473
       +
       							meeting_time_id: finalMeetingTimeId,

     

       2318
       2474
        
       							message: "Upload successful",

     

       2319
       2475
        
       						},

     

       2320
       2476
        
       						{ status: 201 },

+55

src/lib/audio-metadata.integration.test.ts

···

       1
       1
       +
       import { afterAll, describe, expect, test } from "bun:test";

     

       2
       2
       +
       import { extractAudioCreationDate } from "./audio-metadata";

     

       3
       3
       +
       

     

       4
       4
       +
       describe("extractAudioCreationDate (integration)", () => {

     

       5
       5
       +
       	const testAudioPath = "./test-audio-sample.m4a";

     

       6
       6
       +
       

     

       7
       7
       +
       	// Clean up test file after tests

     

       8
       8
       +
       	afterAll(async () => {

     

       9
       9
       +
       		try {

     

       10
       10
       +
       			await Bun.file(testAudioPath).exists().then(async (exists) => {

     

       11
       11
       +
       				if (exists) {

     

       12
       12
       +
       					await Bun.$`rm ${testAudioPath}`;

     

       13
       13
       +
       				}

     

       14
       14
       +
       			});

     

       15
       15
       +
       		} catch {

     

       16
       16
       +
       			// Ignore cleanup errors

     

       17
       17
       +
       		}

     

       18
       18
       +
       	});

     

       19
       19
       +
       

     

       20
       20
       +
       	test("extracts creation date from audio file with metadata", async () => {

     

       21
       21
       +
       		// Create a test audio file with metadata using ffmpeg

     

       22
       22
       +
       		// 1 second silent audio with creation_time metadata

     

       23
       23
       +
       		const creationTime = "2024-01-15T14:30:00.000000Z";

     

       24
       24
       +
       

     

       25
       25
       +
       		// Create the file with metadata

     

       26
       26
       +
       		await Bun.$`ffmpeg -f lavfi -i anullsrc=r=44100:cl=mono -t 1 -metadata creation_time=${creationTime} -y ${testAudioPath}`.quiet();

     

       27
       27
       +
       

     

       28
       28
       +
       		const date = await extractAudioCreationDate(testAudioPath);

     

       29
       29
       +
       

     

       30
       30
       +
       		expect(date).not.toBeNull();

     

       31
       31
       +
       		expect(date).toBeInstanceOf(Date);

     

       32
       32
       +
       		// JavaScript Date.toISOString() uses 3 decimal places, not 6 like the input

     

       33
       33
       +
       		expect(date?.toISOString()).toBe("2024-01-15T14:30:00.000Z");

     

       34
       34
       +
       	});

     

       35
       35
       +
       

     

       36
       36
       +
       	test("returns null for audio file without creation_time metadata", async () => {

     

       37
       37
       +
       		// Create audio file without metadata

     

       38
       38
       +
       		await Bun.$`ffmpeg -f lavfi -i anullsrc=r=44100:cl=mono -t 1 -y ${testAudioPath}`.quiet();

     

       39
       39
       +
       

     

       40
       40
       +
       		const date = await extractAudioCreationDate(testAudioPath);

     

       41
       41
       +
       

     

       42
       42
       +
       		// Should use file modification time as fallback

     

       43
       43
       +
       		expect(date).not.toBeNull();

     

       44
       44
       +
       		expect(date).toBeInstanceOf(Date);

     

       45
       45
       +
       		// Should be very recent (within last minute)

     

       46
       46
       +
       		const now = new Date();

     

       47
       47
       +
       		const diff = now.getTime() - (date?.getTime() ?? 0);

     

       48
       48
       +
       		expect(diff).toBeLessThan(60000); // Less than 1 minute

     

       49
       49
       +
       	});

     

       50
       50
       +
       

     

       51
       51
       +
       	test("returns null for non-existent file", async () => {

     

       52
       52
       +
       		const date = await extractAudioCreationDate("./non-existent-file.m4a");

     

       53
       53
       +
       		expect(date).toBeNull();

     

       54
       54
       +
       	});

     

       55
       55
       +
       });

+128

src/lib/audio-metadata.test.ts

···

       1
       1
       +
       import { describe, expect, test } from "bun:test";

     

       2
       2
       +
       import {

     

       3
       3
       +
       	findMatchingMeetingTime,

     

       4
       4
       +
       	getDayName,

     

       5
       5
       +
       	getDayOfWeek,

     

       6
       6
       +
       	meetingTimeLabelMatchesDay,

     

       7
       7
       +
       } from "./audio-metadata";

     

       8
       8
       +
       

     

       9
       9
       +
       describe("getDayOfWeek", () => {

     

       10
       10
       +
       	test("returns correct day number", () => {

     

       11
       11
       +
       		// January 1, 2024 is a Monday (day 1)

     

       12
       12
       +
       		const monday = new Date("2024-01-01T12:00:00Z");

     

       13
       13
       +
       		expect(getDayOfWeek(monday)).toBe(1);

     

       14
       14
       +
       

     

       15
       15
       +
       		// January 7, 2024 is a Sunday (day 0)

     

       16
       16
       +
       		const sunday = new Date("2024-01-07T12:00:00Z");

     

       17
       17
       +
       		expect(getDayOfWeek(sunday)).toBe(0);

     

       18
       18
       +
       

     

       19
       19
       +
       		// January 6, 2024 is a Saturday (day 6)

     

       20
       20
       +
       		const saturday = new Date("2024-01-06T12:00:00Z");

     

       21
       21
       +
       		expect(getDayOfWeek(saturday)).toBe(6);

     

       22
       22
       +
       	});

     

       23
       23
       +
       });

     

       24
       24
       +
       

     

       25
       25
       +
       describe("getDayName", () => {

     

       26
       26
       +
       	test("returns correct day name", () => {

     

       27
       27
       +
       		expect(getDayName(new Date("2024-01-01T12:00:00Z"))).toBe("Monday");

     

       28
       28
       +
       		expect(getDayName(new Date("2024-01-02T12:00:00Z"))).toBe("Tuesday");

     

       29
       29
       +
       		expect(getDayName(new Date("2024-01-03T12:00:00Z"))).toBe("Wednesday");

     

       30
       30
       +
       		expect(getDayName(new Date("2024-01-04T12:00:00Z"))).toBe("Thursday");

     

       31
       31
       +
       		expect(getDayName(new Date("2024-01-05T12:00:00Z"))).toBe("Friday");

     

       32
       32
       +
       		expect(getDayName(new Date("2024-01-06T12:00:00Z"))).toBe("Saturday");

     

       33
       33
       +
       		expect(getDayName(new Date("2024-01-07T12:00:00Z"))).toBe("Sunday");

     

       34
       34
       +
       	});

     

       35
       35
       +
       });

     

       36
       36
       +
       

     

       37
       37
       +
       describe("meetingTimeLabelMatchesDay", () => {

     

       38
       38
       +
       	test("matches full day names", () => {

     

       39
       39
       +
       		expect(meetingTimeLabelMatchesDay("Monday Lecture", "Monday")).toBe(true);

     

       40
       40
       +
       		expect(meetingTimeLabelMatchesDay("Tuesday Lab", "Tuesday")).toBe(true);

     

       41
       41
       +
       		expect(meetingTimeLabelMatchesDay("Wednesday Discussion", "Wednesday")).toBe(

     

       42
       42
       +
       			true,

     

       43
       43
       +
       		);

     

       44
       44
       +
       	});

     

       45
       45
       +
       

     

       46
       46
       +
       	test("matches 3-letter abbreviations", () => {

     

       47
       47
       +
       		expect(meetingTimeLabelMatchesDay("Mon Lecture", "Monday")).toBe(true);

     

       48
       48
       +
       		expect(meetingTimeLabelMatchesDay("Tue Lab", "Tuesday")).toBe(true);

     

       49
       49
       +
       		expect(meetingTimeLabelMatchesDay("Wed Discussion", "Wednesday")).toBe(

     

       50
       50
       +
       			true,

     

       51
       51
       +
       		);

     

       52
       52
       +
       		expect(meetingTimeLabelMatchesDay("Thu Seminar", "Thursday")).toBe(true);

     

       53
       53
       +
       		expect(meetingTimeLabelMatchesDay("Fri Workshop", "Friday")).toBe(true);

     

       54
       54
       +
       		expect(meetingTimeLabelMatchesDay("Sat Review", "Saturday")).toBe(true);

     

       55
       55
       +
       		expect(meetingTimeLabelMatchesDay("Sun Study", "Sunday")).toBe(true);

     

       56
       56
       +
       	});

     

       57
       57
       +
       

     

       58
       58
       +
       	test("is case insensitive", () => {

     

       59
       59
       +
       		expect(meetingTimeLabelMatchesDay("MONDAY LECTURE", "Monday")).toBe(true);

     

       60
       60
       +
       		expect(meetingTimeLabelMatchesDay("monday lecture", "Monday")).toBe(true);

     

       61
       61
       +
       		expect(meetingTimeLabelMatchesDay("MoNdAy LeCTuRe", "Monday")).toBe(true);

     

       62
       62
       +
       	});

     

       63
       63
       +
       

     

       64
       64
       +
       	test("does not match wrong days", () => {

     

       65
       65
       +
       		expect(meetingTimeLabelMatchesDay("Monday Lecture", "Tuesday")).toBe(false);

     

       66
       66
       +
       		expect(meetingTimeLabelMatchesDay("Wednesday Lab", "Thursday")).toBe(false);

     

       67
       67
       +
       		expect(meetingTimeLabelMatchesDay("Lecture Hall A", "Monday")).toBe(false);

     

       68
       68
       +
       	});

     

       69
       69
       +
       

     

       70
       70
       +
       	test("handles labels without day names", () => {

     

       71
       71
       +
       		expect(meetingTimeLabelMatchesDay("Lecture", "Monday")).toBe(false);

     

       72
       72
       +
       		expect(meetingTimeLabelMatchesDay("Lab Session", "Tuesday")).toBe(false);

     

       73
       73
       +
       		expect(meetingTimeLabelMatchesDay("Section A", "Wednesday")).toBe(false);

     

       74
       74
       +
       	});

     

       75
       75
       +
       });

     

       76
       76
       +
       

     

       77
       77
       +
       describe("findMatchingMeetingTime", () => {

     

       78
       78
       +
       	const meetingTimes = [

     

       79
       79
       +
       		{ id: "mt1", label: "Monday Lecture" },

     

       80
       80
       +
       		{ id: "mt2", label: "Wednesday Discussion" },

     

       81
       81
       +
       		{ id: "mt3", label: "Friday Lab" },

     

       82
       82
       +
       	];

     

       83
       83
       +
       

     

       84
       84
       +
       	test("finds correct meeting time for full day name", () => {

     

       85
       85
       +
       		const monday = new Date("2024-01-01T12:00:00Z"); // Monday

     

       86
       86
       +
       		expect(findMatchingMeetingTime(monday, meetingTimes)).toBe("mt1");

     

       87
       87
       +
       

     

       88
       88
       +
       		const wednesday = new Date("2024-01-03T12:00:00Z"); // Wednesday

     

       89
       89
       +
       		expect(findMatchingMeetingTime(wednesday, meetingTimes)).toBe("mt2");

     

       90
       90
       +
       

     

       91
       91
       +
       		const friday = new Date("2024-01-05T12:00:00Z"); // Friday

     

       92
       92
       +
       		expect(findMatchingMeetingTime(friday, meetingTimes)).toBe("mt3");

     

       93
       93
       +
       	});

     

       94
       94
       +
       

     

       95
       95
       +
       	test("finds correct meeting time for abbreviated day name", () => {

     

       96
       96
       +
       		const abbrevMeetingTimes = [

     

       97
       97
       +
       			{ id: "mt1", label: "Mon Lecture" },

     

       98
       98
       +
       			{ id: "mt2", label: "Wed Discussion" },

     

       99
       99
       +
       			{ id: "mt3", label: "Fri Lab" },

     

       100
       100
       +
       		];

     

       101
       101
       +
       

     

       102
       102
       +
       		const monday = new Date("2024-01-01T12:00:00Z");

     

       103
       103
       +
       		expect(findMatchingMeetingTime(monday, abbrevMeetingTimes)).toBe("mt1");

     

       104
       104
       +
       	});

     

       105
       105
       +
       

     

       106
       106
       +
       	test("returns null when no match found", () => {

     

       107
       107
       +
       		const tuesday = new Date("2024-01-02T12:00:00Z"); // Tuesday

     

       108
       108
       +
       		expect(findMatchingMeetingTime(tuesday, meetingTimes)).toBe(null);

     

       109
       109
       +
       

     

       110
       110
       +
       		const saturday = new Date("2024-01-06T12:00:00Z"); // Saturday

     

       111
       111
       +
       		expect(findMatchingMeetingTime(saturday, meetingTimes)).toBe(null);

     

       112
       112
       +
       	});

     

       113
       113
       +
       

     

       114
       114
       +
       	test("returns null for empty meeting times", () => {

     

       115
       115
       +
       		const monday = new Date("2024-01-01T12:00:00Z");

     

       116
       116
       +
       		expect(findMatchingMeetingTime(monday, [])).toBe(null);

     

       117
       117
       +
       	});

     

       118
       118
       +
       

     

       119
       119
       +
       	test("returns first match when multiple matches exist", () => {

     

       120
       120
       +
       		const duplicateMeetingTimes = [

     

       121
       121
       +
       			{ id: "mt1", label: "Monday Lecture" },

     

       122
       122
       +
       			{ id: "mt2", label: "Monday Lab" },

     

       123
       123
       +
       		];

     

       124
       124
       +
       

     

       125
       125
       +
       		const monday = new Date("2024-01-01T12:00:00Z");

     

       126
       126
       +
       		expect(findMatchingMeetingTime(monday, duplicateMeetingTimes)).toBe("mt1");

     

       127
       127
       +
       	});

     

       128
       128
       +
       });

+144

src/lib/audio-metadata.ts

···

       1
       1
       +
       import { $ } from "bun";

     

       2
       2
       +
       

     

       3
       3
       +
       /**

     

       4
       4
       +
        * Extracts creation date from audio file metadata using ffprobe

     

       5
       5
       +
        * Falls back to file birth time (original creation) if no metadata found

     

       6
       6
       +
        * @param filePath Path to audio file

     

       7
       7
       +
        * @returns Date object or null if not found

     

       8
       8
       +
        */

     

       9
       9
       +
       export async function extractAudioCreationDate(

     

       10
       10
       +
       	filePath: string,

     

       11
       11
       +
       ): Promise<Date | null> {

     

       12
       12
       +
       	try {

     

       13
       13
       +
       		// Use ffprobe to extract creation_time metadata

     

       14
       14
       +
       		// -v quiet: suppress verbose output

     

       15
       15
       +
       		// -print_format json: output as JSON

     

       16
       16
       +
       		// -show_entries format_tags: show all tags to search for date fields

     

       17
       17
       +
       		const result =

     

       18
       18
       +
       			await $`ffprobe -v quiet -print_format json -show_entries format_tags ${filePath}`.text();

     

       19
       19
       +
       

     

       20
       20
       +
       		const metadata = JSON.parse(result);

     

       21
       21
       +
       		const tags = metadata?.format?.tags || {};

     

       22
       22
       +
       

     

       23
       23
       +
       		// Try multiple metadata fields that might contain creation date

     

       24
       24
       +
       		const dateFields = [

     

       25
       25
       +
       			tags.creation_time, // Standard creation_time

     

       26
       26
       +
       			tags.date, // Common date field

     

       27
       27
       +
       			tags.DATE, // Uppercase variant

     

       28
       28
       +
       			tags.year, // Year field

     

       29
       29
       +
       			tags.YEAR, // Uppercase variant

     

       30
       30
       +
       			tags["com.apple.quicktime.creationdate"], // Apple QuickTime

     

       31
       31
       +
       			tags.TDRC, // ID3v2 recording time

     

       32
       32
       +
       			tags.TDRL, // ID3v2 release time

     

       33
       33
       +
       		];

     

       34
       34
       +
       

     

       35
       35
       +
       		for (const dateField of dateFields) {

     

       36
       36
       +
       			if (dateField) {

     

       37
       37
       +
       				const date = new Date(dateField);

     

       38
       38
       +
       				if (!Number.isNaN(date.getTime())) {

     

       39
       39
       +
       					console.log(

     

       40
       40
       +
       						`[AudioMetadata] Extracted creation date from metadata: ${date.toISOString()} from ${filePath}`,

     

       41
       41
       +
       					);

     

       42
       42
       +
       					return date;

     

       43
       43
       +
       				}

     

       44
       44
       +
       			}

     

       45
       45
       +
       		}

     

       46
       46
       +
       

     

       47
       47
       +
       		// Fallback: use file birth time (original creation time on filesystem)

     

       48
       48
       +
       		// This preserves the original file creation date better than mtime

     

       49
       49
       +
       		console.log(

     

       50
       50
       +
       			`[AudioMetadata] No creation_time metadata found, using file birth time`,

     

       51
       51
       +
       		);

     

       52
       52
       +
       		const file = Bun.file(filePath);

     

       53
       53
       +
       		const stat = await file.stat();

     

       54
       54
       +
       		const date = new Date(stat.birthtime || stat.mtime);

     

       55
       55
       +
       		console.log(

     

       56
       56
       +
       			`[AudioMetadata] Using file birth time: ${date.toISOString()} from ${filePath}`,

     

       57
       57
       +
       		);

     

       58
       58
       +
       		return date;

     

       59
       59
       +
       	} catch (error) {

     

       60
       60
       +
       		console.error(

     

       61
       61
       +
       			`[AudioMetadata] Failed to extract metadata from ${filePath}:`,

     

       62
       62
       +
       			error instanceof Error ? error.message : "Unknown error",

     

       63
       63
       +
       		);

     

       64
       64
       +
       		return null;

     

       65
       65
       +
       	}

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

       68
       68
       +
       /**

     

       69
       69
       +
        * Gets day of week from a date (0 = Sunday, 6 = Saturday)

     

       70
       70
       +
        */

     

       71
       71
       +
       export function getDayOfWeek(date: Date): number {

     

       72
       72
       +
       	return date.getDay();

     

       73
       73
       +
       }

     

       74
       74
       +
       

     

       75
       75
       +
       /**

     

       76
       76
       +
        * Gets day name from a date

     

       77
       77
       +
        */

     

       78
       78
       +
       export function getDayName(date: Date): string {

     

       79
       79
       +
       	const days = [

     

       80
       80
       +
       		"Sunday",

     

       81
       81
       +
       		"Monday",

     

       82
       82
       +
       		"Tuesday",

     

       83
       83
       +
       		"Wednesday",

     

       84
       84
       +
       		"Thursday",

     

       85
       85
       +
       		"Friday",

     

       86
       86
       +
       		"Saturday",

     

       87
       87
       +
       	];

     

       88
       88
       +
       	return days[date.getDay()] || "Unknown";

     

       89
       89
       +
       }

     

       90
       90
       +
       

     

       91
       91
       +
       /**

     

       92
       92
       +
        * Checks if a meeting time label matches a specific day

     

       93
       93
       +
        * Labels like "Monday Lecture", "Tuesday Lab", "Wed Discussion" should match

     

       94
       94
       +
        */

     

       95
       95
       +
       export function meetingTimeLabelMatchesDay(

     

       96
       96
       +
       	label: string,

     

       97
       97
       +
       	dayName: string,

     

       98
       98
       +
       ): boolean {

     

       99
       99
       +
       	const lowerLabel = label.toLowerCase();

     

       100
       100
       +
       	const lowerDay = dayName.toLowerCase();

     

       101
       101
       +
       

     

       102
       102
       +
       	// Check for full day name

     

       103
       103
       +
       	if (lowerLabel.includes(lowerDay)) {

     

       104
       104
       +
       		return true;

     

       105
       105
       +
       	}

     

       106
       106
       +
       

     

       107
       107
       +
       	// Check for 3-letter abbreviations

     

       108
       108
       +
       	const abbrev = dayName.slice(0, 3).toLowerCase();

     

       109
       109
       +
       	if (lowerLabel.includes(abbrev)) {

     

       110
       110
       +
       		return true;

     

       111
       111
       +
       	}

     

       112
       112
       +
       

     

       113
       113
       +
       	return false;

     

       114
       114
       +
       }

     

       115
       115
       +
       

     

       116
       116
       +
       /**

     

       117
       117
       +
        * Finds the best matching meeting time for a given date

     

       118
       118
       +
        * @param date Date from audio metadata

     

       119
       119
       +
        * @param meetingTimes Available meeting times for the class

     

       120
       120
       +
        * @returns Meeting time ID or null if no match

     

       121
       121
       +
        */

     

       122
       122
       +
       export function findMatchingMeetingTime(

     

       123
       123
       +
       	date: Date,

     

       124
       124
       +
       	meetingTimes: Array<{ id: string; label: string }>,

     

       125
       125
       +
       ): string | null {

     

       126
       126
       +
       	const dayName = getDayName(date);

     

       127
       127
       +
       

     

       128
       128
       +
       	// Find meeting time that matches the day

     

       129
       129
       +
       	const match = meetingTimes.find((mt) =>

     

       130
       130
       +
       		meetingTimeLabelMatchesDay(mt.label, dayName),

     

       131
       131
       +
       	);

     

       132
       132
       +
       

     

       133
       133
       +
       	if (match) {

     

       134
       134
       +
       		console.log(

     

       135
       135
       +
       			`[AudioMetadata] Matched ${dayName} to meeting time: ${match.label}`,

     

       136
       136
       +
       		);

     

       137
       137
       +
       		return match.id;

     

       138
       138
       +
       	}

     

       139
       139
       +
       

     

       140
       140
       +
       	console.log(

     

       141
       141
       +
       		`[AudioMetadata] No meeting time found matching ${dayName} in available options: ${meetingTimes.map((mt) => mt.label).join(", ")}`,

     

       142
       142
       +
       	);

     

       143
       143
       +
       	return null;

     

       144
       144
       +
       }