@luckydye/calendar 1.3.1 → 1.4.0

package/src/app.ts

@@ -1,31 +1,36 @@
-import { CalendarViewElement } from "./lib.ts";
+import { activeCalendarStore } from "./ActiveCalendarStore.js";
 import "./CalDAVConfig.ts";
 import type { CalDAVConfigElement } from "./CalDAVConfig.ts";
+import { CalDAVSource } from "./CalDAVSource.js";
 import {
-	CalendarIntegration,
 	type Calendar,
+	CalendarIntegration,
 	type CalendarSource,
 } from "./CalendarIntegration.js";
-import { CalDAVSource } from "./CalDAVSource.js";
-import { fetchICalEventsWithNotifications, parseICalEvents, parseICalEventsWithNotifications } from "./ICal.js";
-import { initializeTheme } from "./Theme.js";
-import { InMemorySource } from "./InMemorySource.js";
+import type { CalendarEvent } from "./CalendarInternal.js";
+import { sanitizeEventDescription } from "./DescriptionSanitizer.js";
 import { GoogleCalendarSource } from "./GoogleCalendarSource.js";
+import {
+	fetchICalEventsWithNotifications,
+	parseICalEvents,
+	parseICalEventsWithNotifications,
+} from "./ICal.js";
+import { InMemorySource } from "./InMemorySource.js";
 import { InhouseBookingSource } from "./InhouseBookingSource.js";
-import { fetchTimeseriesJsonEvents } from "./TimeseriesJson.js";
-import { queueStatus } from "./StatusMessage.js";
-import { activeCalendarStore } from "./ActiveCalendarStore.js";
-import type { CalendarEvent } from "./CalendarInternal.js";
 import { registerKeybinds } from "./Keybinds.js";
-import "./StatusBar.js";
 import { NotificationScheduler } from "./NotificationScheduler.js";
-import serviceWorkerUrl from "./service-worker.js?url";
+import "./StatusBar.js";
 import type { StatusBarElement } from "./StatusBar.js";
+import { queueStatus } from "./StatusMessage.js";
+import { initializeTheme } from "./Theme.js";
+import { fetchTimeseriesJsonEvents } from "./TimeseriesJson.js";
+import { CalendarViewElement } from "./lib.ts";
+import serviceWorkerUrl from "./service-worker.js?url";
 
 try {
-  customElements.define("calendar-view", CalendarViewElement);
-} catch(err) {
-  console.error(err);
+	customElements.define("calendar-view", CalendarViewElement);
+} catch (err) {
+	console.error(err);
 }
 
 // Initialize theme on app start
@@ -36,16 +41,158 @@ const calendarElement = document.querySelector(
 ) as CalendarViewElement;
 const calendar = calendarElement.internal;
 
-registerKeybinds(
-	[
-		{ key: "r", cmdOrCtrl: true, shift: true, action: () => calendarElement.forceSync() },
-		{ key: "c", cmdOrCtrl: true, action: () => calendarElement.copySelectedEvents() },
-		{ key: "Backspace", action: () => calendarElement.deleteSelectedEvents() },
-		{ key: "Delete", action: () => calendarElement.deleteSelectedEvents() },
-		{ key: "Escape", action: () => calendarElement.escape() },
-		{ key: "t", action: () => calendarElement.scrollToToday() },
-	],
-);
+type PromptApiLanguageModel = {
+	availability?: () => Promise<string>;
+	create: (options?: unknown) => Promise<{
+		promptStreaming: (
+			prompt: string,
+			options?: unknown,
+		) => Promise<ReadableStream<string>> | ReadableStream<string>;
+		destroy?: () => void;
+	}>;
+};
+
+function getPromptApiLanguageModel(): PromptApiLanguageModel | null {
+	const fromGlobal = (globalThis as { LanguageModel?: unknown }).LanguageModel;
+	if (fromGlobal) return fromGlobal as PromptApiLanguageModel;
+
+	const fromWindow = (window as { ai?: { languageModel?: unknown } }).ai
+		?.languageModel;
+	if (!fromWindow) return null;
+	return fromWindow as PromptApiLanguageModel;
+}
+
+let summaryAbortController: AbortController | null = null;
+let summarySession: { destroy?: () => void } | null = null;
+let summaryRequestToken = 0;
+let activeSummaryKey: string | null = null;
+
+function abortActiveDescriptionSummary(): void {
+	if (summaryAbortController) {
+		summaryAbortController.abort();
+		summaryAbortController = null;
+	}
+	if (summarySession) {
+		summarySession.destroy?.();
+		summarySession = null;
+	}
+	if (activeSummaryKey) {
+		calendarElement.cancelDescriptionSummary(activeSummaryKey);
+		activeSummaryKey = null;
+	}
+	summaryRequestToken++;
+}
+
+async function streamDescriptionSummary(
+	key: string,
+	description: string,
+): Promise<void> {
+	const sanitizedDescription = sanitizeEventDescription(description);
+	abortActiveDescriptionSummary();
+	activeSummaryKey = key;
+	const token = summaryRequestToken;
+	calendarElement.startDescriptionSummary(key);
+
+	const languageModel = getPromptApiLanguageModel();
+	if (!languageModel) {
+		calendarElement.failDescriptionSummary(
+			key,
+			"Prompt API not available in this browser.",
+		);
+		activeSummaryKey = null;
+		return;
+	}
+
+	const controller = new AbortController();
+	summaryAbortController = controller;
+	let session: { destroy?: () => void } | null = null;
+
+	try {
+		const availability = await languageModel.availability?.();
+		if (token !== summaryRequestToken || key !== activeSummaryKey) return;
+		if (availability === "unavailable") {
+			throw new Error("Prompt API model is unavailable.");
+		}
+
+		session = await languageModel.create();
+		summarySession = session;
+		const prompt = [
+			"Summarize this calendar event description in 2-3 concise sentences.",
+			"Keep critical details like dates, times, links, and action items.",
+			"Return plain text only.",
+			"",
+			sanitizedDescription,
+		].join("\n");
+
+		const stream = await Promise.resolve(
+			session.promptStreaming(prompt, { signal: controller.signal }),
+		);
+		const reader = stream.getReader();
+		try {
+			while (true) {
+				const { value, done } = await reader.read();
+				if (done) break;
+				if (
+					token !== summaryRequestToken ||
+					key !== activeSummaryKey ||
+					controller.signal.aborted
+				) {
+					return;
+				}
+				if (value) {
+					calendarElement.appendDescriptionSummaryChunk(key, value);
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+
+		if (token !== summaryRequestToken || key !== activeSummaryKey) return;
+		calendarElement.finishDescriptionSummary(key);
+		activeSummaryKey = null;
+	} catch (error) {
+		if (
+			controller.signal.aborted ||
+			token !== summaryRequestToken ||
+			key !== activeSummaryKey
+		) {
+			return;
+		}
+		calendarElement.failDescriptionSummary(
+			key,
+			error instanceof Error
+				? error.message
+				: "Failed to generate description summary.",
+		);
+		activeSummaryKey = null;
+	} finally {
+		if (summaryAbortController === controller) {
+			summaryAbortController = null;
+		}
+		if (summarySession === session) {
+			summarySession = null;
+		}
+		session?.destroy?.();
+	}
+}
+
+registerKeybinds([
+	{
+		key: "r",
+		cmdOrCtrl: true,
+		shift: true,
+		action: () => calendarElement.forceSync(),
+	},
+	{
+		key: "c",
+		cmdOrCtrl: true,
+		action: () => calendarElement.copySelectedEvents(),
+	},
+	{ key: "Backspace", action: () => calendarElement.deleteSelectedEvents() },
+	{ key: "Delete", action: () => calendarElement.deleteSelectedEvents() },
+	{ key: "Escape", action: () => calendarElement.escape() },
+	{ key: "t", action: () => calendarElement.scrollToToday() },
+]);
 
 let workerPromise: Promise<ServiceWorkerRegistration> | undefined;
 
@@ -61,10 +208,14 @@ if ("serviceWorker" in navigator) {
 // Initialize notification scheduler
 const notificationScheduler = new NotificationScheduler(() => workerPromise);
 
-async function scheduleNotificationsForEvents(events: CalendarEvent[]): Promise<void> {
+async function scheduleNotificationsForEvents(
+	events: CalendarEvent[],
+): Promise<void> {
 	const now = new Date();
 	const next24Hours = new Date(now.getTime() + 24 * 60 * 60 * 1000);
-	const upcoming = events.filter(e => e.start >= now && e.start <= next24Hours && e.reminders?.length);
+	const upcoming = events.filter(
+		(e) => e.start >= now && e.start <= next24Hours && e.reminders?.length,
+	);
 	for (const event of upcoming) {
 		await notificationScheduler.scheduleEventNotifications(event);
 	}
@@ -105,14 +256,36 @@ async function requestNotificationPermission() {
 	}
 }
 
-calendarElement.addEventListener("event-click", () => {
-	requestNotificationPermission();
-}, { once: true });
+calendarElement.addEventListener(
+	"event-click",
+	() => {
+		requestNotificationPermission();
+	},
+	{ once: true },
+);
+
+calendarElement.addEventListener("request-description-summary", (e: Event) => {
+	const { key, description } = (e as CustomEvent).detail as {
+		key: string;
+		description: string;
+	};
+	void streamDescriptionSummary(key, description);
+});
+
+calendarElement.addEventListener("cancel-description-summary", (e: Event) => {
+	const { key } = (e as CustomEvent).detail as { key: string };
+	if (key === activeSummaryKey) {
+		abortActiveDescriptionSummary();
+	}
+});
 
 // Load iCal files
 const integration = new CalendarIntegration(calendar);
 
-async function sync(cal: Calendar, options?: { force?: boolean }): Promise<void> {
+async function sync(
+	cal: Calendar,
+	options?: { force?: boolean },
+): Promise<void> {
 	const events = await integration.sync(cal, options);
 	await scheduleNotificationsForEvents(events);
 }
@@ -124,9 +297,14 @@ let mutationsSettledResolve: (() => void) | null = null;
 let mutationsSettledPromise: Promise<void> | null = null;
 const dirtyCalendars = new Set<Calendar>();
 
-async function withMutation(cal: Calendar, fn: () => Promise<void>): Promise<void> {
+async function withMutation(
+	cal: Calendar,
+	fn: () => Promise<void>,
+): Promise<void> {
 	if (pendingMutations === 0) {
-		mutationsSettledPromise = new Promise(r => { mutationsSettledResolve = r; });
+		mutationsSettledPromise = new Promise((r) => {
+			mutationsSettledResolve = r;
+		});
 	}
 	pendingMutations++;
 	try {
@@ -158,11 +336,11 @@ async function waitForMutations(): Promise<void> {
 	await calendar.initPromise;
 
 	// Register sample source
-	const sampleSource = new InMemorySource('sample', "Sample Events", '#10b981');
+	const sampleSource = new InMemorySource("sample", "Sample Events", "#10b981");
 	const sampleCalendar = createInMemoryCalendar(sampleSource);
 	loadedCalendars.set(sampleCalendar.id, sampleCalendar);
 	activeCalendarStore.registerCalendar(sampleCalendar);
-	
+
 	// Create sidebar with CalDAV config
 	const sidebar = document.createElement("div");
 	sidebar.slot = "sidebar";
@@ -198,7 +376,6 @@ async function waitForMutations(): Promise<void> {
 	updateActiveCalendarColor();
 })();
 
-
 // Store for loaded calendars
 const loadedCalendars: Map<string, Calendar> = new Map();
 let config: CalDAVConfigElement;
@@ -243,7 +420,7 @@ async function createCalDAVCalendars(
 			username,
 			password,
 		},
-		source.enabled
+		source.enabled,
 	);
 
 	// Fetch all calendars and the current user's email from the CalDAV server
@@ -267,7 +444,11 @@ async function createCalDAVCalendars(
 			calendarUrl: calInfo.url,
 
 			async fetchEvents(): Promise<CalendarEvent[]> {
-				return caldavSource.fetchEventsForCalendar(calInfo.url, calInfo.displayName, calInfo.color);
+				return caldavSource.fetchEventsForCalendar(
+					calInfo.url,
+					calInfo.displayName,
+					calInfo.color,
+				);
 			},
 
 			async createEvent(
@@ -277,15 +458,18 @@ async function createCalDAVCalendars(
 			},
 
 			async updateEvent(
-				id: string,
+				event: CalendarEvent,
 				updates: Partial<CalendarEvent>,
 			): Promise<CalendarEvent> {
-				return caldavSource.updateEvent(id, { ...updates, calendarId: calInfo.url });
+				return caldavSource.updateEvent(event, {
+					...updates,
+					calendarId: calInfo.url,
+				});
 			},
 
 			async deleteEvent(id: string): Promise<void> {
-				const eventUrl = `${calInfo.url.replace(/\/$/, '')}/${id}.ics`;
-				await caldavSource.request(eventUrl, 'DELETE', undefined, {});
+				const eventUrl = `${calInfo.url.replace(/\/$/, "")}/${id}.ics`;
+				await caldavSource.request(eventUrl, "DELETE", undefined, {});
 			},
 		});
 	}
@@ -305,7 +489,11 @@ function createICalCalendar(source: CalendarSource): Calendar {
 		sourceType: "ical",
 
 		async fetchEvents(): Promise<CalendarEvent[]> {
-			const result = await fetchICalEventsWithNotifications(source.credentials, source.color, source.name);
+			const result = await fetchICalEventsWithNotifications(
+				source.credentials,
+				source.color,
+				source.name,
+			);
 			return result.events;
 		},
 		// iCal calendars are read-only by default
@@ -325,7 +513,11 @@ function createTimeseriesJsonCalendar(source: CalendarSource): Calendar {
 
 		async fetchEvents(): Promise<CalendarEvent[]> {
 			return fetchTimeseriesJsonEvents(
-				source.credentials as { url: string; timestampField?: string; titleField?: string },
+				source.credentials as {
+					url: string;
+					timestampField?: string;
+					titleField?: string;
+				},
 				source.color,
 				source.name,
 				source.id,
@@ -348,7 +540,7 @@ function createGoogleCalendar(source: CalendarSource): Calendar {
 			tokenExpiry: source.credentials.tokenExpiry,
 			calendarId: calendarId,
 		},
-		source.enabled
+		source.enabled,
 	);
 
 	return {
@@ -372,10 +564,10 @@ function createGoogleCalendar(source: CalendarSource): Calendar {
 		},
 
 		async updateEvent(
-			id: string,
+			event: CalendarEvent,
 			updates: Partial<CalendarEvent>,
 		): Promise<CalendarEvent> {
-			return googleSource.updateEvent(id, updates);
+			return googleSource.updateEvent(event, updates);
 		},
 
 		async deleteEvent(id: string): Promise<void> {
@@ -396,7 +588,7 @@ function createInhouseCalendar(source: CalendarSource): Calendar {
 			unitId: source.credentials.unitId,
 			startHour: source.credentials.startHour,
 		},
-		source.enabled
+		source.enabled,
 	);
 
 	return {
@@ -419,10 +611,10 @@ function createInhouseCalendar(source: CalendarSource): Calendar {
 		},
 
 		async updateEvent(
-			id: string,
+			event: CalendarEvent,
 			updates: Partial<CalendarEvent>,
 		): Promise<CalendarEvent> {
-			return inhouseSource.updateEvent(id, updates);
+			return inhouseSource.updateEvent(event, updates);
 		},
 
 		async deleteEvent(id: string): Promise<void> {
@@ -458,12 +650,12 @@ function createInMemoryCalendar(source: InMemorySource): Calendar {
 		},
 
 		async updateEvent(
-			id: string,
+			event: CalendarEvent,
 			updates: Partial<CalendarEvent>,
 		): Promise<CalendarEvent> {
 			if (!source.updateEvent)
 				throw new Error("Source does not support updateEvent");
-			return source.updateEvent(id, updates);
+			return source.updateEvent(event, updates);
 		},
 
 		async deleteEvent(id: string): Promise<void> {
@@ -564,7 +756,9 @@ async function syncCalDAV(force = false) {
 			}
 		} else if (source.type === "timeseries-json") {
 			if (!source.credentials?.url) {
-				console.warn(`Skipping Timeseries JSON source ${source.name}: missing URL`);
+				console.warn(
+					`Skipping Timeseries JSON source ${source.name}: missing URL`,
+				);
 				continue;
 			}
 
@@ -575,11 +769,16 @@ async function syncCalDAV(force = false) {
 			try {
 				await sync(calendar, { force });
 			} catch (error) {
-				console.error(`Sync error for Timeseries JSON source ${source.name}:`, error);
+				console.error(
+					`Sync error for Timeseries JSON source ${source.name}:`,
+					error,
+				);
 			}
 		} else if (source.type === "google") {
 			if (!source.credentials?.accessToken) {
-				console.warn(`Skipping Google Calendar source ${source.name}: missing access token`);
+				console.warn(
+					`Skipping Google Calendar source ${source.name}: missing access token`,
+				);
 				continue;
 			}
 
@@ -591,11 +790,19 @@ async function syncCalDAV(force = false) {
 			try {
 				await sync(calendar, { force });
 			} catch (error) {
-				console.error(`Sync error for Google Calendar source ${source.name}:`, error);
+				console.error(
+					`Sync error for Google Calendar source ${source.name}:`,
+					error,
+				);
 			}
 		} else if (source.type === "inhouse") {
-			if (!source.credentials?.sessionCookie || !source.credentials?.employeeId) {
-				console.warn(`Skipping Inhouse Booking source ${source.name}: missing session cookie or employee ID`);
+			if (
+				!source.credentials?.sessionCookie ||
+				!source.credentials?.employeeId
+			) {
+				console.warn(
+					`Skipping Inhouse Booking source ${source.name}: missing session cookie or employee ID`,
+				);
 				continue;
 			}
 
@@ -606,7 +813,10 @@ async function syncCalDAV(force = false) {
 			try {
 				await sync(calendar, { force });
 			} catch (error) {
-				console.error(`Sync error for Inhouse Booking source ${source.name}:`, error);
+				console.error(
+					`Sync error for Inhouse Booking source ${source.name}:`,
+					error,
+				);
 			}
 		} else {
 			console.warn(`Unknown source type for ${source.name}: ${source.type}`);
@@ -618,7 +828,7 @@ async function syncCalDAV(force = false) {
 	updateLockedCalendars();
 
 	// Push calendar list to sidebar
-	config.calendars = Array.from(loadedCalendars.values()).map(cal => ({
+	config.calendars = Array.from(loadedCalendars.values()).map((cal) => ({
 		id: cal.id,
 		name: cal.name,
 		color: cal.color,
@@ -721,7 +931,7 @@ function showProjectPickerDialog(
 			const filtered = filter
 				? projects.filter((p) =>
 						p.name.toLowerCase().includes(filter.toLowerCase()),
-					)
+				  )
 				: projects;
 			for (const project of filtered) {
 				const item = document.createElement("button");
@@ -798,46 +1008,17 @@ calendarElement.addEventListener("create-event", async (e) => {
 		lastSynced: new Date(),
 	});
 	try {
-		await withMutation(calendar, () => calendar.createEvent({ id, title: "New Event", start, end, isAllDay }));
+		await withMutation(calendar, () =>
+			calendar.createEvent({ id, title: "New Event", start, end, isAllDay }),
+		);
 	} catch (error) {
 		calendarElement.internal.removeEventOptimistically(id);
 		console.error("Failed to create event:", error);
-		queueStatus(`Failed to create event: ${error instanceof Error ? error.message : String(error)}`);
-	}
-});
-
-calendarElement.addEventListener("move-event", async (e) => {
-	const { event, start, end } = e.detail;
-
-	const calendar = findCalendarForEvent(event);
-
-	if (!calendar) {
-		queueStatus("Cannot move event: calendar not found.");
-		return;
-	}
-
-	if (!calendar.updateEvent) {
-		queueStatus(`Calendar "${calendar.name}" does not support moving events.`);
-		return;
-	}
-
-	console.log(
-		"Moving event:",
-		event.id,
-		"from",
-		event.start,
-		"to",
-		start,
-		"on calendar:",
-		calendar.name,
-	);
-	try {
-		calendarElement.internal.applyEventOptimistically({ ...event, start, end });
-		await withMutation(calendar, () => calendar.updateEvent(event.id, { start, end }));
-	} catch (error) {
-		calendarElement.internal.applyEventOptimistically(event);
-		console.error("Failed to move event:", error);
-		queueStatus(`Failed to move event: ${error instanceof Error ? error.message : String(error)}`);
+		queueStatus(
+			`Failed to create event: ${
+				error instanceof Error ? error.message : String(error)
+			}`,
+		);
 	}
 });
 
@@ -858,17 +1039,16 @@ calendarElement.addEventListener("update-event", async (e) => {
 		return;
 	}
 
-	console.log(
-		"Updating event:",
-		event
-	);
+	console.log("Updating event:", event);
 	try {
 		calendarElement.internal.applyEventOptimistically({ ...event, ...updates });
-		await withMutation(calendar, () => calendar.updateEvent(event.id, updates));
+		await withMutation(calendar, () => calendar.updateEvent(event, updates));
 
 		if ("reminders" in updates) {
 			const eventWithReminders = { ...event, ...updates };
-			await notificationScheduler.scheduleEventNotifications(eventWithReminders);
+			await notificationScheduler.scheduleEventNotifications(
+				eventWithReminders,
+			);
 
 			if (calendarElement.selectedEventForDetail?.id === event.id) {
 				calendarElement.selectedEventForDetail = eventWithReminders;
@@ -877,7 +1057,11 @@ calendarElement.addEventListener("update-event", async (e) => {
 	} catch (error) {
 		calendarElement.internal.applyEventOptimistically(event);
 		console.error("Failed to update event:", error);
-		queueStatus(`Failed to update event: ${error instanceof Error ? error.message : String(error)}`);
+		queueStatus(
+			`Failed to update event: ${
+				error instanceof Error ? error.message : String(error)
+			}`,
+		);
 	}
 });
 
@@ -909,9 +1093,7 @@ calendarElement.addEventListener("delete-events", async (e) => {
 		const calendar = findCalendarForEvent(calendarEvents[0]);
 
 		if (!calendar) {
-			queueStatus(
-				`Cannot delete events: calendar "${calendarId}" not found.`,
-			);
+			queueStatus(`Cannot delete events: calendar "${calendarId}" not found.`);
 			continue;
 		}
 
@@ -939,7 +1121,11 @@ calendarElement.addEventListener("delete-events", async (e) => {
 				calendarElement.internal.applyEventOptimistically(event);
 			}
 			console.error("Failed to delete event:", error);
-			queueStatus(`Failed to delete event: ${error instanceof Error ? error.message : String(error)}`);
+			queueStatus(
+				`Failed to delete event: ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+			);
 		}
 	}
 });
@@ -957,7 +1143,8 @@ calendarElement.addEventListener("force-sync", async () => {
 
 calendarElement.addEventListener("load-notifications", async () => {
 	try {
-		const notifications = await notificationScheduler.getScheduledNotifications();
+		const notifications =
+			await notificationScheduler.getScheduledNotifications();
 		calendarElement.setScheduledNotifications(notifications);
 	} catch (error) {
 		console.error("Failed to load scheduled notifications:", error);
@@ -1028,7 +1215,6 @@ calendarElement.addEventListener("import-ical", async (e) => {
 	}
 });
 
-
 function updateActiveCalendarColor() {
 	const calendar = activeCalendarStore.getActiveCalendar();
 	calendarElement.activeCalendarColor = calendar?.color ?? null;
@@ -1037,8 +1223,8 @@ function updateActiveCalendarColor() {
 
 function updateEnabledCalendars() {
 	const enabledCalendarIdentifiers = Array.from(loadedCalendars.values())
-		.filter(cal => cal.enabled)
-		.flatMap(cal => {
+		.filter((cal) => cal.enabled)
+		.flatMap((cal) => {
 			// For CalDAV, use the calendar URL; for others, use the source ID
 			const identifiers = [];
 			if (cal.calendarUrl) {
@@ -1054,8 +1240,8 @@ function updateEnabledCalendars() {
 
 function updateLockedCalendars() {
 	const lockedCalendarIdentifiers = Array.from(loadedCalendars.values())
-		.filter(cal => (cal as { locked?: boolean }).locked)
-		.flatMap(cal => {
+		.filter((cal) => (cal as { locked?: boolean }).locked)
+		.flatMap((cal) => {
 			// For CalDAV, use the calendar URL; for others, use the source ID
 			const identifiers = [];
 			if (cal.calendarUrl) {