Merge remote-tracking branch 'origin/master' into feat/web-search

# Conflicts:
#	bun.lock

apps/admin-dashboard/src/components/reminder-crud-panel.tsx

@@ -1,639 +0,0 @@
-import type { Dispatch, FormEvent, SetStateAction } from "react"
-
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
-import { Check, Loader2, Pencil, Plus, RefreshCw, RotateCcw, Save, Trash2, X } from "lucide-react"
-import { useMemo, useState } from "react"
-import { toast } from "sonner"
-
-import type { FeedItem } from "@/lib/api"
-
-import { Badge } from "@/components/ui/badge"
-import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
-import { Input } from "@/components/ui/input"
-import { Label } from "@/components/ui/label"
-import {
-	Select,
-	SelectContent,
-	SelectItem,
-	SelectTrigger,
-	SelectValue,
-} from "@/components/ui/select"
-import { Switch } from "@/components/ui/switch"
-import { executeSourceAction, fetchFeed } from "@/lib/api"
-
-const REMINDER_SOURCE_ID = "freya.reminders"
-
-type ReminderPriority = "low" | "normal" | "high"
-type ReminderFrequency = "daily" | "weekly" | "monthly" | "yearly"
-type ReminderEditScope = "this-occurrence" | "this-and-future" | "entire-series"
-
-interface ReminderRecurrence {
-	frequency: ReminderFrequency
-	interval: number
-	count?: number
-	until?: string
-}
-
-interface ReminderFeedData extends Record<string, unknown> {
-	reminderId: string
-	occurrenceId: string
-	title: string
-	notes: string | null
-	originalDueAt: string
-	dueAt: string
-	timeZone: string
-	recurrence: ReminderRecurrence | null
-	priority: ReminderPriority
-	completedAt: string | null
-}
-
-interface ReminderFormState {
-	title: string
-	notes: string
-	dueAt: string
-	priority: ReminderPriority
-	scope: ReminderEditScope
-	recurs: boolean
-	frequency: ReminderFrequency
-	interval: string
-	count: string
-	until: string
-}
-
-const emptyForm: ReminderFormState = {
-	title: "",
-	notes: "",
-	dueAt: toLocalInput(new Date()),
-	priority: "normal",
-	scope: "entire-series",
-	recurs: false,
-	frequency: "daily",
-	interval: "1",
-	count: "",
-	until: "",
-}
-
-export function ReminderCrudPanel() {
-	const queryClient = useQueryClient()
-	const [form, setForm] = useState<ReminderFormState>(emptyForm)
-	const [editing, setEditing] = useState<ReminderFeedData | null>(null)
-	const [deleteScopes, setDeleteScopes] = useState<Record<string, ReminderEditScope>>({})
-
-	const {
-		data: feed,
-		isFetching,
-		refetch,
-	} = useQuery({
-		queryKey: ["feed"],
-		queryFn: fetchFeed,
-	})
-
-	const reminders = useMemo(
-		() => (feed?.items ?? []).filter(isReminderItem).map((item) => item.data),
-		[feed],
-	)
-
-	const actionMutation = useMutation({
-		mutationFn: (input: { actionId: string; params: unknown }) =>
-			executeSourceAction(REMINDER_SOURCE_ID, input.actionId, input.params),
-	})
-
-	const busy = actionMutation.isPending
-	const canConfigureRecurrence = !editing || form.scope !== "this-occurrence"
-
-	async function runAction(actionId: string, params: unknown, success: string): Promise<boolean> {
-		try {
-			await actionMutation.mutateAsync({ actionId, params })
-			await queryClient.invalidateQueries({ queryKey: ["feed"] })
-			toast.success(success)
-			return true
-		} catch (err) {
-			toast.error(err instanceof Error ? err.message : String(err))
-			return false
-		}
-	}
-
-	async function handleSubmit(event: FormEvent<HTMLFormElement>) {
-		event.preventDefault()
-
-		if (editing) {
-			const patch = formToPatch(formFromReminder(editing), form)
-			if (Object.keys(patch).length === 0) {
-				toast.info("No changes to save")
-				return
-			}
-
-			const saved = await runAction(
-				"update-reminder",
-				{
-					reminderId: editing.reminderId,
-					scope: form.scope,
-					occurrenceDueAt: editing.originalDueAt,
-					patch,
-				},
-				"Reminder updated",
-			)
-			if (saved) resetForm()
-			return
-		} else {
-			const created = await runAction(
-				"create-reminder",
-				formToCreatePayload(form),
-				"Reminder created",
-			)
-			if (created) resetForm()
-		}
-	}
-
-	function startEdit(reminder: ReminderFeedData) {
-		setEditing(reminder)
-		setForm(formFromReminder(reminder))
-	}
-
-	function resetForm() {
-		setEditing(null)
-		setForm({ ...emptyForm, dueAt: toLocalInput(new Date()) })
-	}
-
-	function getDeleteScope(reminder: ReminderFeedData): ReminderEditScope {
-		return (
-			deleteScopes[reminderKey(reminder)] ??
-			(reminder.recurrence ? "this-occurrence" : "entire-series")
-		)
-	}
-
-	function setDeleteScope(reminder: ReminderFeedData, scope: ReminderEditScope) {
-		setDeleteScopes((prev) => ({ ...prev, [reminderKey(reminder)]: scope }))
-	}
-
-	return (
-		<Card className="-mx-4">
-			<CardHeader className="pb-4">
-				<div className="flex items-center justify-between gap-3">
-					<CardTitle className="text-sm">Reminders</CardTitle>
-					<Button size="sm" variant="outline" onClick={() => refetch()} disabled={isFetching}>
-						{isFetching ? (
-							<Loader2 className="size-3.5 animate-spin" />
-						) : (
-							<RefreshCw className="size-3.5" />
-						)}
-						Refresh
-					</Button>
-				</div>
-			</CardHeader>
-			<CardContent className="space-y-5">
-				<form className="grid gap-4" onSubmit={handleSubmit}>
-					<div className="grid gap-3 sm:grid-cols-2">
-						<div className="space-y-2 sm:col-span-2">
-							<Label htmlFor="reminder-title" className="text-xs font-medium">
-								Title
-							</Label>
-							<Input
-								id="reminder-title"
-								value={form.title}
-								onChange={(event) => setFormField(setForm, "title", event.target.value)}
-								disabled={busy}
-								required
-							/>
-						</div>
-
-						<div className="space-y-2 sm:col-span-2">
-							<Label htmlFor="reminder-notes" className="text-xs font-medium">
-								Notes
-							</Label>
-							<Input
-								id="reminder-notes"
-								value={form.notes}
-								onChange={(event) => setFormField(setForm, "notes", event.target.value)}
-								disabled={busy}
-							/>
-						</div>
-
-						<div className="space-y-2">
-							<Label htmlFor="reminder-due-at" className="text-xs font-medium">
-								Due
-							</Label>
-							<Input
-								id="reminder-due-at"
-								type="datetime-local"
-								value={form.dueAt}
-								onChange={(event) => setFormField(setForm, "dueAt", event.target.value)}
-								disabled={busy}
-								required
-							/>
-						</div>
-
-						<div className="space-y-2">
-							<Label htmlFor="reminder-priority" className="text-xs font-medium">
-								Priority
-							</Label>
-							<Select
-								value={form.priority}
-								onValueChange={(value) =>
-									setFormField(setForm, "priority", value as ReminderPriority)
-								}
-								disabled={busy}
-							>
-								<SelectTrigger id="reminder-priority">
-									<SelectValue />
-								</SelectTrigger>
-								<SelectContent>
-									<SelectItem value="low">Low</SelectItem>
-									<SelectItem value="normal">Normal</SelectItem>
-									<SelectItem value="high">High</SelectItem>
-								</SelectContent>
-							</Select>
-						</div>
-
-						{editing?.recurrence && (
-							<div className="space-y-2 sm:col-span-2">
-								<Label htmlFor="reminder-edit-scope" className="text-xs font-medium">
-									Edit scope
-								</Label>
-								<Select
-									value={form.scope}
-									onValueChange={(value) =>
-										setFormField(setForm, "scope", value as ReminderEditScope)
-									}
-									disabled={busy}
-								>
-									<SelectTrigger id="reminder-edit-scope">
-										<SelectValue />
-									</SelectTrigger>
-									<SelectContent>
-										<SelectItem value="this-occurrence">This occurrence</SelectItem>
-										<SelectItem value="this-and-future">This and future</SelectItem>
-										<SelectItem value="entire-series">Entire series</SelectItem>
-									</SelectContent>
-								</Select>
-							</div>
-						)}
-					</div>
-
-					{canConfigureRecurrence && (
-						<div className="grid gap-3 rounded-md border p-3 sm:grid-cols-4">
-							<div className="flex items-center justify-between gap-3 sm:col-span-4">
-								<Label htmlFor="reminder-recurs" className="text-xs font-medium">
-									Recurring
-								</Label>
-								<Switch
-									id="reminder-recurs"
-									checked={form.recurs}
-									onCheckedChange={(checked) => setFormField(setForm, "recurs", checked)}
-									disabled={busy}
-								/>
-							</div>
-
-							{form.recurs && (
-								<>
-									<div className="space-y-2 sm:col-span-2">
-										<Label htmlFor="reminder-frequency" className="text-xs font-medium">
-											Frequency
-										</Label>
-										<Select
-											value={form.frequency}
-											onValueChange={(value) =>
-												setFormField(setForm, "frequency", value as ReminderFrequency)
-											}
-											disabled={busy}
-										>
-											<SelectTrigger id="reminder-frequency">
-												<SelectValue />
-											</SelectTrigger>
-											<SelectContent>
-												<SelectItem value="daily">Daily</SelectItem>
-												<SelectItem value="weekly">Weekly</SelectItem>
-												<SelectItem value="monthly">Monthly</SelectItem>
-												<SelectItem value="yearly">Yearly</SelectItem>
-											</SelectContent>
-										</Select>
-									</div>
-
-									<div className="space-y-2">
-										<Label htmlFor="reminder-interval" className="text-xs font-medium">
-											Interval
-										</Label>
-										<Input
-											id="reminder-interval"
-											type="number"
-											min={1}
-											value={form.interval}
-											onChange={(event) => setFormField(setForm, "interval", event.target.value)}
-											disabled={busy}
-										/>
-									</div>
-
-									<div className="space-y-2">
-										<Label htmlFor="reminder-count" className="text-xs font-medium">
-											Count
-										</Label>
-										<Input
-											id="reminder-count"
-											type="number"
-											min={1}
-											value={form.count}
-											onChange={(event) => setFormField(setForm, "count", event.target.value)}
-											disabled={busy}
-										/>
-									</div>
-
-									<div className="space-y-2 sm:col-span-4">
-										<Label htmlFor="reminder-until" className="text-xs font-medium">
-											Until
-										</Label>
-										<Input
-											id="reminder-until"
-											type="datetime-local"
-											value={form.until}
-											onChange={(event) => setFormField(setForm, "until", event.target.value)}
-											disabled={busy}
-										/>
-									</div>
-								</>
-							)}
-						</div>
-					)}
-
-					<div className="flex justify-end gap-2">
-						{editing && (
-							<Button type="button" variant="outline" onClick={resetForm} disabled={busy}>
-								<X className="size-3.5" />
-								Cancel
-							</Button>
-						)}
-						<Button type="submit" disabled={busy || !form.title || !form.dueAt}>
-							{busy ? <Loader2 className="size-3.5 animate-spin" /> : <Save className="size-3.5" />}
-							{editing ? "Update" : "Create"}
-						</Button>
-					</div>
-				</form>
-
-				<div className="space-y-2">
-					<div className="flex items-center justify-between text-xs text-muted-foreground">
-						<span>
-							{reminders.length} {reminders.length === 1 ? "occurrence" : "occurrences"}
-						</span>
-						{!editing && (
-							<Button size="sm" variant="ghost" onClick={resetForm} disabled={busy}>
-								<Plus className="size-3.5" />
-								New
-							</Button>
-						)}
-					</div>
-
-					{reminders.length === 0 && (
-						<div className="rounded-md border border-dashed px-3 py-6 text-center text-sm text-muted-foreground">
-							No reminders in the current feed.
-						</div>
-					)}
-
-					{reminders.map((reminder) => {
-						const deleteScope = getDeleteScope(reminder)
-						return (
-							<ReminderRow
-								key={reminderKey(reminder)}
-								reminder={reminder}
-								busy={busy}
-								deleteScope={deleteScope}
-								onDeleteScopeChange={(scope) => setDeleteScope(reminder, scope)}
-								onEdit={() => startEdit(reminder)}
-								onComplete={() =>
-									runAction(
-										reminder.completedAt ? "uncomplete-reminder" : "complete-reminder",
-										{
-											reminderId: reminder.reminderId,
-											occurrenceDueAt: reminder.originalDueAt,
-										},
-										reminder.completedAt ? "Reminder reopened" : "Reminder completed",
-									)
-								}
-								onDelete={() => {
-									if (
-										!confirm(
-											`Delete ${formatScope(deleteScope).toLowerCase()} for "${reminder.title}"?`,
-										)
-									) {
-										return
-									}
-									void runAction(
-										"delete-reminder",
-										{
-											reminderId: reminder.reminderId,
-											scope: deleteScope,
-											occurrenceDueAt: reminder.originalDueAt,
-										},
-										"Reminder deleted",
-									).then((deleted) => {
-										if (deleted && editing?.reminderId === reminder.reminderId) resetForm()
-									})
-								}}
-							/>
-						)
-					})}
-				</div>
-			</CardContent>
-		</Card>
-	)
-}
-
-function ReminderRow({
-	reminder,
-	busy,
-	deleteScope,
-	onDeleteScopeChange,
-	onEdit,
-	onComplete,
-	onDelete,
-}: {
-	reminder: ReminderFeedData
-	busy: boolean
-	deleteScope: ReminderEditScope
-	onDeleteScopeChange: (scope: ReminderEditScope) => void
-	onEdit: () => void
-	onComplete: () => void
-	onDelete: () => void
-}) {
-	return (
-		<div className="flex items-start justify-between gap-3 rounded-md border px-3 py-2">
-			<div className="min-w-0 space-y-1">
-				<div className="flex flex-wrap items-center gap-2">
-					<span className="truncate text-sm font-medium">{reminder.title}</span>
-					<Badge variant={reminder.completedAt ? "secondary" : "outline"} className="text-xs">
-						{reminder.completedAt ? "Done" : reminder.priority}
-					</Badge>
-					{reminder.recurrence && (
-						<Badge variant="secondary" className="text-xs">
-							{formatRecurrence(reminder.recurrence)}
-						</Badge>
-					)}
-				</div>
-				<div className="text-xs text-muted-foreground">{formatDate(reminder.dueAt)}</div>
-				{reminder.notes && <div className="text-xs text-muted-foreground">{reminder.notes}</div>}
-			</div>
-			<div className="flex shrink-0 flex-wrap items-center justify-end gap-1">
-				{reminder.recurrence && (
-					<Select
-						value={deleteScope}
-						onValueChange={(value) => onDeleteScopeChange(value as ReminderEditScope)}
-						disabled={busy}
-					>
-						<SelectTrigger className="h-8 w-[86px] text-xs">
-							<SelectValue />
-						</SelectTrigger>
-						<SelectContent>
-							<SelectItem value="this-occurrence">This</SelectItem>
-							<SelectItem value="this-and-future">Future</SelectItem>
-							<SelectItem value="entire-series">All</SelectItem>
-						</SelectContent>
-					</Select>
-				)}
-				<Button size="sm" variant="ghost" onClick={onComplete} disabled={busy}>
-					{reminder.completedAt ? (
-						<RotateCcw className="size-3.5" />
-					) : (
-						<Check className="size-3.5" />
-					)}
-				</Button>
-				<Button size="sm" variant="ghost" onClick={onEdit} disabled={busy}>
-					<Pencil className="size-3.5" />
-				</Button>
-				<Button size="sm" variant="ghost" onClick={onDelete} disabled={busy}>
-					<Trash2 className="size-3.5 text-destructive" />
-				</Button>
-			</div>
-		</div>
-	)
-}
-
-function formToCreatePayload(form: ReminderFormState): Record<string, unknown> {
-	return {
-		title: form.title.trim(),
-		notes: form.notes.trim() || null,
-		dueAt: toIsoString(form.dueAt),
-		timeZone: localTimeZone(),
-		priority: form.priority,
-		recurrence: recurrenceValueFromForm(form),
-	}
-}
-
-function formToPatch(initial: ReminderFormState, form: ReminderFormState): Record<string, unknown> {
-	const patch: Record<string, unknown> = {}
-	const title = form.title.trim()
-	const notes = form.notes.trim() || null
-	const initialNotes = initial.notes.trim() || null
-
-	if (title !== initial.title.trim()) patch.title = title
-	if (notes !== initialNotes) patch.notes = notes
-	if (form.dueAt !== initial.dueAt) {
-		patch.dueAt = toIsoString(form.dueAt)
-		patch.timeZone = localTimeZone()
-	}
-	if (form.priority !== initial.priority) patch.priority = form.priority
-	if (form.scope !== "this-occurrence" && recurrenceChanged(initial, form)) {
-		patch.recurrence = recurrenceValueFromForm(form)
-	}
-
-	return patch
-}
-
-function recurrenceValueFromForm(form: ReminderFormState): ReminderRecurrence | null {
-	return form.recurs ? recurrenceFromForm(form) : null
-}
-
-function recurrenceFromForm(form: ReminderFormState): ReminderRecurrence {
-	const recurrence: ReminderRecurrence = {
-		frequency: form.frequency,
-		interval: Math.max(1, Number(form.interval) || 1),
-	}
-
-	const count = Number(form.count)
-	if (Number.isInteger(count) && count > 0) recurrence.count = count
-	if (form.until) recurrence.until = toIsoString(form.until)
-
-	return recurrence
-}
-
-function formFromReminder(reminder: ReminderFeedData): ReminderFormState {
-	return {
-		title: reminder.title,
-		notes: reminder.notes ?? "",
-		dueAt: toLocalInput(new Date(reminder.dueAt)),
-		priority: reminder.priority,
-		scope: reminder.recurrence ? "this-occurrence" : "entire-series",
-		recurs: reminder.recurrence !== null,
-		frequency: reminder.recurrence?.frequency ?? "daily",
-		interval: String(reminder.recurrence?.interval ?? 1),
-		count: reminder.recurrence?.count ? String(reminder.recurrence.count) : "",
-		until: reminder.recurrence?.until ? toLocalInput(new Date(reminder.recurrence.until)) : "",
-	}
-}
-
-function setFormField<TKey extends keyof ReminderFormState>(
-	setForm: Dispatch<SetStateAction<ReminderFormState>>,
-	key: TKey,
-	value: ReminderFormState[TKey],
-) {
-	setForm((prev) => ({ ...prev, [key]: value }))
-}
-
-function recurrenceChanged(initial: ReminderFormState, form: ReminderFormState): boolean {
-	return (
-		JSON.stringify(recurrenceValueFromForm(initial)) !==
-		JSON.stringify(recurrenceValueFromForm(form))
-	)
-}
-
-function reminderKey(reminder: ReminderFeedData): string {
-	return `${reminder.reminderId}:${reminder.occurrenceId}`
-}
-
-function isReminderItem(item: FeedItem): item is FeedItem & { data: ReminderFeedData } {
-	return (
-		item.sourceId === REMINDER_SOURCE_ID &&
-		typeof item.data.reminderId === "string" &&
-		typeof item.data.occurrenceId === "string" &&
-		typeof item.data.title === "string" &&
-		typeof item.data.originalDueAt === "string" &&
-		typeof item.data.dueAt === "string"
-	)
-}
-
-function toLocalInput(date: Date): string {
-	const offsetMs = date.getTimezoneOffset() * 60 * 1000
-	return new Date(date.getTime() - offsetMs).toISOString().slice(0, 16)
-}
-
-function toIsoString(value: string): string {
-	return new Date(value).toISOString()
-}
-
-function localTimeZone(): string {
-	return Intl.DateTimeFormat().resolvedOptions().timeZone
-}
-
-function formatDate(value: string): string {
-	return new Date(value).toLocaleString(undefined, {
-		month: "short",
-		day: "numeric",
-		hour: "numeric",
-		minute: "2-digit",
-	})
-}
-
-function formatRecurrence(recurrence: ReminderRecurrence): string {
-	return recurrence.interval === 1
-		? recurrence.frequency
-		: `${recurrence.frequency} / ${recurrence.interval}`
-}
-
-function formatScope(scope: ReminderEditScope): string {
-	switch (scope) {
-		case "this-occurrence":
-			return "this occurrence"
-		case "this-and-future":
-			return "this and future"
-		case "entire-series":
-			return "entire series"
-	}
-}

apps/admin-dashboard/src/components/source-config-panel.tsx

@@ -5,7 +5,6 @@ import { toast } from "sonner"
 
 import type { ConfigFieldDef, SourceDefinition } from "@/lib/api"
 
-import { ReminderCrudPanel } from "@/components/reminder-crud-panel"
 import { Badge } from "@/components/ui/badge"
 import { Button } from "@/components/ui/button"
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
@@ -67,17 +66,11 @@ export function SourceConfigPanel({ source, onUpdate }: SourceConfigPanelProps)
 		return creds
 	}
 
-	function hasUserConfigFields(): boolean {
-		return Object.values(source.fields).some((field) => !isCredentialField(field))
-	}
-
 	function buildReplaceBody(enabledValue: boolean): Parameters<typeof replaceSource>[1] {
 		const body: Parameters<typeof replaceSource>[1] = { enabled: enabledValue }
-
-		if (hasUserConfigFields()) {
+		if (Object.keys(source.fields).length > 0) {
 			body.config = getUserConfig()
 		}
-
 		return body
 	}
 
@@ -268,8 +261,6 @@ export function SourceConfigPanel({ source, onUpdate }: SourceConfigPanelProps)
 			)}
 
 			{source.id === "freya.location" && <LocationCard />}
-
-			{source.id === "freya.reminders" && enabled && <ReminderCrudPanel />}
 		</div>
 	)
 }
@@ -480,17 +471,6 @@ function FieldInput({
 		)
 	}
 
-	if (field.type === "boolean") {
-		return (
-			<div className="flex items-center justify-between gap-3 rounded-md border px-3 py-2">
-				<Label htmlFor={name} className="text-xs font-medium">
-					{labelContent}
-				</Label>
-				<Switch id={name} checked={value === true} onCheckedChange={onChange} disabled={disabled} />
-			</div>
-		)
-	}
-
 	return (
 		<div className="space-y-2">
 			<Label htmlFor={name} className="text-xs font-medium">
@@ -518,8 +498,6 @@ function buildInitialValues(
 			values[name] = saved[name]
 		} else if (field.defaultValue !== undefined) {
 			values[name] = field.defaultValue
-		} else if (field.type === "boolean") {
-			values[name] = false
 		} else if (field.type === "multiselect") {
 			values[name] = []
 		} else {

apps/admin-dashboard/src/lib/api.ts

@@ -9,12 +9,12 @@ function serverBase() {
 }
 
 export interface ConfigFieldDef {
-	type: "string" | "number" | "select" | "multiselect" | "boolean"
+	type: "string" | "number" | "select" | "multiselect"
 	label: string
 	required?: boolean
 	description?: string
 	secret?: boolean
-	defaultValue?: string | number | string[] | boolean
+	defaultValue?: string | number | string[]
 	options?: { label: string; value: string }[]
 }
 
@@ -151,49 +151,12 @@ const sourceDefinitions: SourceDefinition[] = [
 			},
 		},
 	},
-	{
-		id: "freya.reminders",
-		name: "Reminders",
-		description: "One-off and recurring reminders in the contextual feed.",
-		fields: {
-			lookAheadMs: {
-				type: "number",
-				label: "Look-ahead Milliseconds",
-				defaultValue: 24 * 60 * 60 * 1000,
-				description: "How far into the future reminders should appear in the feed.",
-			},
-			lookBackMs: {
-				type: "number",
-				label: "Look-back Milliseconds",
-				defaultValue: 24 * 60 * 60 * 1000,
-				description: "How far into the past due reminders should remain visible.",
-			},
-			includeCompleted: {
-				type: "boolean",
-				label: "Include Completed",
-				defaultValue: false,
-				description: "Show completed reminder occurrences in the feed.",
-			},
-			defaultTimeZone: {
-				type: "string",
-				label: "Default Timezone",
-				defaultValue: "UTC",
-				description: "IANA timezone used when new reminders omit a timezone.",
-			},
-		},
-	},
 	{
 		id: "freya.web-search",
 		name: "Web Search",
 		description: "Exa web search action. Requires EXA_API_KEY on the backend.",
 		fields: {},
 	},
-	{
-		id: "freya.google-maps",
-		name: "Google Maps",
-		description: "Google Maps Grounding Lite MCP tools for places, weather, routes, and Place IDs.",
-		fields: {},
-	},
 ]
 
 export function fetchSources(): Promise<SourceDefinition[]> {
@@ -263,25 +226,6 @@ export async function updateSourceCredentials(
 	}
 }
 
-export async function executeSourceAction(
-	sourceId: string,
-	actionId: string,
-	params: unknown,
-): Promise<unknown> {
-	const res = await fetch(`${serverBase()}/sources/${sourceId}/actions/${actionId}`, {
-		method: "POST",
-		headers: { "Content-Type": "application/json" },
-		credentials: "include",
-		body: JSON.stringify(params),
-	})
-	if (!res.ok) {
-		const data = (await res.json()) as { error?: string }
-		throw new Error(data.error ?? `Failed to execute source action: ${res.status}`)
-	}
-	const data = (await res.json()) as { result: unknown }
-	return data.result
-}
-
 export interface LocationInput {
 	lat: number
 	lng: number

apps/admin-dashboard/src/routes/_dashboard.tsx

@@ -8,7 +8,6 @@ import {
 	Link,
 } from "@tanstack/react-router"
 import {
-	Bell,
 	Calendar,
 	CalendarDays,
 	CircleDot,
@@ -16,7 +15,6 @@ import {
 	Loader2,
 	TrainFront,
 	LogOut,
-	Map as MapIcon,
 	MapPin,
 	Rss,
 	Server,
@@ -51,8 +49,6 @@ const SOURCE_ICONS: Record<string, React.ComponentType<{ className?: string }>>
 	"freya.weather": CloudSun,
 	"freya.caldav": CalendarDays,
 	"freya.google-calendar": Calendar,
-	"freya.google-maps": MapIcon,
-	"freya.reminders": Bell,
 	"freya.tfl": TrainFront,
 }
 

apps/freya-backend/drizzle/0000_wakeful_scorpion.sql

@@ -49,33 +49,6 @@ CREATE TABLE "user_sources" (
 	CONSTRAINT "user_sources_user_id_source_id_unique" UNIQUE("user_id","source_id")
 );
 --> statement-breakpoint
-CREATE TABLE "reminders" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"user_id" text NOT NULL,
-	"title" text NOT NULL,
-	"notes" text,
-	"due_at" timestamp NOT NULL,
-	"time_zone" text DEFAULT 'UTC' NOT NULL,
-	"recurrence" jsonb,
-	"priority" text DEFAULT 'normal' NOT NULL,
-	"created_at" timestamp DEFAULT now() NOT NULL,
-	"updated_at" timestamp DEFAULT now() NOT NULL
-);
---> statement-breakpoint
-CREATE TABLE "reminder_occurrence_overrides" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"user_id" text NOT NULL,
-	"reminder_id" uuid NOT NULL,
-	"occurrence_id" text NOT NULL,
-	"original_due_at" timestamp NOT NULL,
-	"patch" jsonb,
-	"completed_at" timestamp,
-	"deleted_at" timestamp,
-	"created_at" timestamp DEFAULT now() NOT NULL,
-	"updated_at" timestamp DEFAULT now() NOT NULL,
-	CONSTRAINT "reminder_occurrence_overrides_reminder_id_occurrence_id_unique" UNIQUE("reminder_id","occurrence_id")
-);
---> statement-breakpoint
 CREATE TABLE "verification" (
 	"id" text PRIMARY KEY NOT NULL,
 	"identifier" text NOT NULL,
@@ -88,13 +61,6 @@ CREATE TABLE "verification" (
 ALTER TABLE "account" ADD CONSTRAINT "account_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "session" ADD CONSTRAINT "session_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "user_sources" ADD CONSTRAINT "user_sources_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "reminders" ADD CONSTRAINT "reminders_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "reminder_occurrence_overrides" ADD CONSTRAINT "reminder_occurrence_overrides_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "reminder_occurrence_overrides" ADD CONSTRAINT "reminder_occurrence_overrides_reminder_id_reminders_id_fk" FOREIGN KEY ("reminder_id") REFERENCES "public"."reminders"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
 CREATE INDEX "account_userId_idx" ON "account" USING btree ("user_id");--> statement-breakpoint
 CREATE INDEX "session_userId_idx" ON "session" USING btree ("user_id");--> statement-breakpoint
-CREATE INDEX "reminders_user_id_due_at_idx" ON "reminders" USING btree ("user_id","due_at");--> statement-breakpoint
-CREATE INDEX "reminders_user_id_updated_at_idx" ON "reminders" USING btree ("user_id","updated_at");--> statement-breakpoint
-CREATE INDEX "reminder_occurrence_overrides_user_id_reminder_id_idx" ON "reminder_occurrence_overrides" USING btree ("user_id","reminder_id");--> statement-breakpoint
-CREATE INDEX "reminder_occurrence_overrides_user_id_original_due_at_idx" ON "reminder_occurrence_overrides" USING btree ("user_id","original_due_at");--> statement-breakpoint
-CREATE INDEX "verification_identifier_idx" ON "verification" USING btree ("identifier");
+CREATE INDEX "verification_identifier_idx" ON "verification" USING btree ("identifier");

apps/freya-backend/drizzle/meta/0000_snapshot.json

@@ -441,296 +441,6 @@
       "policies": {},
       "checkConstraints": {},
       "isRLSEnabled": false
-    },
-    "public.reminders": {
-      "name": "reminders",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "uuid",
-          "primaryKey": true,
-          "notNull": true,
-          "default": "gen_random_uuid()"
-        },
-        "user_id": {
-          "name": "user_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "title": {
-          "name": "title",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "notes": {
-          "name": "notes",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "due_at": {
-          "name": "due_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "time_zone": {
-          "name": "time_zone",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "'UTC'"
-        },
-        "recurrence": {
-          "name": "recurrence",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "priority": {
-          "name": "priority",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "'normal'"
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        }
-      },
-      "indexes": {
-        "reminders_user_id_due_at_idx": {
-          "name": "reminders_user_id_due_at_idx",
-          "columns": [
-            {
-              "expression": "user_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "due_at",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        },
-        "reminders_user_id_updated_at_idx": {
-          "name": "reminders_user_id_updated_at_idx",
-          "columns": [
-            {
-              "expression": "user_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "updated_at",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        }
-      },
-      "foreignKeys": {
-        "reminders_user_id_user_id_fk": {
-          "name": "reminders_user_id_user_id_fk",
-          "tableFrom": "reminders",
-          "tableTo": "user",
-          "columnsFrom": [
-            "user_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "cascade",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.reminder_occurrence_overrides": {
-      "name": "reminder_occurrence_overrides",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "uuid",
-          "primaryKey": true,
-          "notNull": true,
-          "default": "gen_random_uuid()"
-        },
-        "user_id": {
-          "name": "user_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "reminder_id": {
-          "name": "reminder_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "occurrence_id": {
-          "name": "occurrence_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "original_due_at": {
-          "name": "original_due_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "patch": {
-          "name": "patch",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "completed_at": {
-          "name": "completed_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "deleted_at": {
-          "name": "deleted_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        }
-      },
-      "indexes": {
-        "reminder_occurrence_overrides_user_id_reminder_id_idx": {
-          "name": "reminder_occurrence_overrides_user_id_reminder_id_idx",
-          "columns": [
-            {
-              "expression": "user_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "reminder_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        },
-        "reminder_occurrence_overrides_user_id_original_due_at_idx": {
-          "name": "reminder_occurrence_overrides_user_id_original_due_at_idx",
-          "columns": [
-            {
-              "expression": "user_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "original_due_at",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        }
-      },
-      "foreignKeys": {
-        "reminder_occurrence_overrides_user_id_user_id_fk": {
-          "name": "reminder_occurrence_overrides_user_id_user_id_fk",
-          "tableFrom": "reminder_occurrence_overrides",
-          "tableTo": "user",
-          "columnsFrom": [
-            "user_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "cascade",
-          "onUpdate": "no action"
-        },
-        "reminder_occurrence_overrides_reminder_id_reminders_id_fk": {
-          "name": "reminder_occurrence_overrides_reminder_id_reminders_id_fk",
-          "tableFrom": "reminder_occurrence_overrides",
-          "tableTo": "reminders",
-          "columnsFrom": [
-            "reminder_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "cascade",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {
-        "reminder_occurrence_overrides_reminder_id_occurrence_id_unique": {
-          "name": "reminder_occurrence_overrides_reminder_id_occurrence_id_unique",
-          "nullsNotDistinct": false,
-          "columns": [
-            "reminder_id",
-            "occurrence_id"
-          ]
-        }
-      },
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
     }
   },
   "enums": {},
@@ -744,4 +454,4 @@
     "schemas": {},
     "tables": {}
   }
-}
+}

apps/freya-backend/drizzle/meta/0001_snapshot.json

@@ -463,296 +463,6 @@
       "policies": {},
       "checkConstraints": {},
       "isRLSEnabled": false
-    },
-    "public.reminders": {
-      "name": "reminders",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "uuid",
-          "primaryKey": true,
-          "notNull": true,
-          "default": "gen_random_uuid()"
-        },
-        "user_id": {
-          "name": "user_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "title": {
-          "name": "title",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "notes": {
-          "name": "notes",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "due_at": {
-          "name": "due_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "time_zone": {
-          "name": "time_zone",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "'UTC'"
-        },
-        "recurrence": {
-          "name": "recurrence",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "priority": {
-          "name": "priority",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "'normal'"
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        }
-      },
-      "indexes": {
-        "reminders_user_id_due_at_idx": {
-          "name": "reminders_user_id_due_at_idx",
-          "columns": [
-            {
-              "expression": "user_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "due_at",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        },
-        "reminders_user_id_updated_at_idx": {
-          "name": "reminders_user_id_updated_at_idx",
-          "columns": [
-            {
-              "expression": "user_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "updated_at",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        }
-      },
-      "foreignKeys": {
-        "reminders_user_id_user_id_fk": {
-          "name": "reminders_user_id_user_id_fk",
-          "tableFrom": "reminders",
-          "tableTo": "user",
-          "columnsFrom": [
-            "user_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "cascade",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.reminder_occurrence_overrides": {
-      "name": "reminder_occurrence_overrides",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "uuid",
-          "primaryKey": true,
-          "notNull": true,
-          "default": "gen_random_uuid()"
-        },
-        "user_id": {
-          "name": "user_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "reminder_id": {
-          "name": "reminder_id",
-          "type": "uuid",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "occurrence_id": {
-          "name": "occurrence_id",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "original_due_at": {
-          "name": "original_due_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "patch": {
-          "name": "patch",
-          "type": "jsonb",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "completed_at": {
-          "name": "completed_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "deleted_at": {
-          "name": "deleted_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "created_at": {
-          "name": "created_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        },
-        "updated_at": {
-          "name": "updated_at",
-          "type": "timestamp",
-          "primaryKey": false,
-          "notNull": true,
-          "default": "now()"
-        }
-      },
-      "indexes": {
-        "reminder_occurrence_overrides_user_id_reminder_id_idx": {
-          "name": "reminder_occurrence_overrides_user_id_reminder_id_idx",
-          "columns": [
-            {
-              "expression": "user_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "reminder_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        },
-        "reminder_occurrence_overrides_user_id_original_due_at_idx": {
-          "name": "reminder_occurrence_overrides_user_id_original_due_at_idx",
-          "columns": [
-            {
-              "expression": "user_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "original_due_at",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        }
-      },
-      "foreignKeys": {
-        "reminder_occurrence_overrides_user_id_user_id_fk": {
-          "name": "reminder_occurrence_overrides_user_id_user_id_fk",
-          "tableFrom": "reminder_occurrence_overrides",
-          "tableTo": "user",
-          "columnsFrom": [
-            "user_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "cascade",
-          "onUpdate": "no action"
-        },
-        "reminder_occurrence_overrides_reminder_id_reminders_id_fk": {
-          "name": "reminder_occurrence_overrides_reminder_id_reminders_id_fk",
-          "tableFrom": "reminder_occurrence_overrides",
-          "tableTo": "reminders",
-          "columnsFrom": [
-            "reminder_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "cascade",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {
-        "reminder_occurrence_overrides_reminder_id_occurrence_id_unique": {
-          "name": "reminder_occurrence_overrides_reminder_id_occurrence_id_unique",
-          "nullsNotDistinct": false,
-          "columns": [
-            "reminder_id",
-            "occurrence_id"
-          ]
-        }
-      },
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
     }
   },
   "enums": {},
@@ -766,4 +476,4 @@
     "schemas": {},
     "tables": {}
   }
-}
+}

apps/freya-backend/drizzle/meta/_journal.json

@@ -17,4 +17,4 @@
       "breakpoints": true
     }
   ]
-}
+}

apps/freya-backend/package.json

@@ -18,9 +18,7 @@
 		"@freya/core": "workspace:*",
 		"@freya/source-caldav": "workspace:*",
 		"@freya/source-google-calendar": "workspace:*",
-		"@freya/source-google-maps": "workspace:*",
 		"@freya/source-location": "workspace:*",
-		"@freya/source-reminders": "workspace:*",
 		"@freya/source-tfl": "workspace:*",
 		"@freya/source-weatherkit": "workspace:*",
 		"@freya/source-web-search": "workspace:*",

apps/freya-backend/src/db/schema.ts

@@ -60,66 +60,3 @@ export const userSources = pgTable(
 		index("user_sources_user_id_enabled_idx").on(t.userId, t.enabled),
 	],
 )
-
-// ---------------------------------------------------------------------------
-// FREYA — reminders source storage
-// ---------------------------------------------------------------------------
-
-export const reminders = pgTable(
-	"reminders",
-	{
-		id: uuid("id").primaryKey().defaultRandom(),
-		userId: text("user_id")
-			.notNull()
-			.references(() => user.id, { onDelete: "cascade" }),
-		title: text("title").notNull(),
-		notes: text("notes"),
-		dueAt: timestamp("due_at").notNull(),
-		timeZone: text("time_zone").notNull().default("UTC"),
-		recurrence: jsonb("recurrence"),
-		priority: text("priority").notNull().default("normal"),
-		createdAt: timestamp("created_at").notNull().defaultNow(),
-		updatedAt: timestamp("updated_at")
-			.notNull()
-			.defaultNow()
-			.$onUpdate(() => new Date()),
-	},
-	(t) => [
-		index("reminders_user_id_due_at_idx").on(t.userId, t.dueAt),
-		index("reminders_user_id_updated_at_idx").on(t.userId, t.updatedAt),
-	],
-)
-
-export const reminderOccurrenceOverrides = pgTable(
-	"reminder_occurrence_overrides",
-	{
-		id: uuid("id").primaryKey().defaultRandom(),
-		userId: text("user_id")
-			.notNull()
-			.references(() => user.id, { onDelete: "cascade" }),
-		reminderId: uuid("reminder_id")
-			.notNull()
-			.references(() => reminders.id, { onDelete: "cascade" }),
-		occurrenceId: text("occurrence_id").notNull(),
-		originalDueAt: timestamp("original_due_at").notNull(),
-		patch: jsonb("patch"),
-		completedAt: timestamp("completed_at"),
-		deletedAt: timestamp("deleted_at"),
-		createdAt: timestamp("created_at").notNull().defaultNow(),
-		updatedAt: timestamp("updated_at")
-			.notNull()
-			.defaultNow()
-			.$onUpdate(() => new Date()),
-	},
-	(t) => [
-		unique("reminder_occurrence_overrides_reminder_id_occurrence_id_unique").on(
-			t.reminderId,
-			t.occurrenceId,
-		),
-		index("reminder_occurrence_overrides_user_id_reminder_id_idx").on(t.userId, t.reminderId),
-		index("reminder_occurrence_overrides_user_id_original_due_at_idx").on(
-			t.userId,
-			t.originalDueAt,
-		),
-	],
-)

apps/freya-backend/src/google-maps/provider.test.ts

@@ -1,55 +0,0 @@
-import type { GoogleMapsSourceOptions } from "@freya/source-google-maps"
-
-import { describe, expect, test } from "bun:test"
-
-import { GoogleMapsSourceProvider } from "./provider.ts"
-
-type McpClient = NonNullable<GoogleMapsSourceOptions["client"]>
-
-class MockMcpClient implements McpClient {
-	async listTools(): ReturnType<McpClient["listTools"]> {
-		return { tools: [] }
-	}
-
-	async readResource(
-		_params: Parameters<McpClient["readResource"]>[0],
-	): ReturnType<McpClient["readResource"]> {
-		throw new Error("unexpected resource read")
-	}
-
-	async callTool(_params: Parameters<McpClient["callTool"]>[0]): ReturnType<McpClient["callTool"]> {
-		return { structuredContent: {} }
-	}
-}
-
-describe("GoogleMapsSourceProvider", () => {
-	test("sourceId is freya.google-maps", () => {
-		const provider = new GoogleMapsSourceProvider({ apiKey: "key" })
-		expect(provider.sourceId).toBe("freya.google-maps")
-	})
-
-	test("throws when service API key is empty", () => {
-		expect(() => new GoogleMapsSourceProvider({ apiKey: "" })).toThrow(
-			"Google Maps MCP API key must be configured",
-		)
-	})
-
-	test("returns source with service API key", async () => {
-		const provider = new GoogleMapsSourceProvider({ apiKey: "key" })
-
-		const source = await provider.feedSourceForUser("user-1", {}, null)
-
-		expect(source.id).toBe("freya.google-maps")
-	})
-
-	test("allows injected test client with service API key", async () => {
-		const provider = new GoogleMapsSourceProvider({
-			apiKey: "key",
-			client: new MockMcpClient(),
-		})
-
-		const source = await provider.feedSourceForUser("user-1", {}, null)
-
-		expect(source.id).toBe("freya.google-maps")
-	})
-})

apps/freya-backend/src/google-maps/provider.ts

@@ -1,39 +0,0 @@
-import { GoogleMapsSource, type GoogleMapsSourceOptions } from "@freya/source-google-maps"
-
-import type { FeedSourceProvider } from "../session/feed-source-provider.ts"
-
-export interface GoogleMapsSourceProviderOptions {
-	readonly apiKey: string
-	readonly client?: GoogleMapsSourceOptions["client"]
-}
-
-export class GoogleMapsSourceProvider implements FeedSourceProvider {
-	readonly sourceId = "freya.google-maps"
-
-	private readonly apiKey: string
-	private readonly client: GoogleMapsSourceProviderOptions["client"]
-
-	constructor(options: GoogleMapsSourceProviderOptions) {
-		if (!nonEmptyString(options.apiKey)) {
-			throw new Error("Google Maps MCP API key must be configured")
-		}
-
-		this.apiKey = options.apiKey
-		this.client = options.client
-	}
-
-	async feedSourceForUser(
-		_userId: string,
-		_config: unknown,
-		_credentials: unknown,
-	): Promise<GoogleMapsSource> {
-		return new GoogleMapsSource({
-			apiKey: this.apiKey,
-			client: this.client,
-		})
-	}
-}
-
-function nonEmptyString(value: string): boolean {
-	return typeof value === "string" && value.trim().length > 0
-}

apps/freya-backend/src/reminders/provider.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-import type { Database } from "../db/index.ts"
-
-import { ReminderSourceProvider } from "./provider.ts"
-
-const fakeDb = {} as Database
-
-describe("ReminderSourceProvider", () => {
-	const provider = new ReminderSourceProvider({ db: fakeDb })
-
-	test("sourceId is freya.reminders", () => {
-		expect(provider.sourceId).toBe("freya.reminders")
-	})
-
-	test("throws when config has extra keys", async () => {
-		await expect(
-			provider.feedSourceForUser("user-1", { lookAheadMs: 1000, extra: true }, null),
-		).rejects.toThrow("Invalid reminders config")
-	})
-
-	test("throws when defaultTimeZone is invalid", async () => {
-		await expect(
-			provider.feedSourceForUser("user-1", { defaultTimeZone: "Not/AZone" }, null),
-		).rejects.toThrow("Invalid reminders config")
-	})
-
-	test("returns ReminderSource with valid config", async () => {
-		const source = await provider.feedSourceForUser(
-			"user-1",
-			{
-				lookAheadMs: 48 * 60 * 60 * 1000,
-				lookBackMs: 60 * 60 * 1000,
-				includeCompleted: true,
-				defaultTimeZone: "Europe/London",
-			},
-			null,
-		)
-
-		expect(source).toBeDefined()
-		expect(source.id).toBe("freya.reminders")
-	})
-
-	test("returns ReminderSource with empty config", async () => {
-		const source = await provider.feedSourceForUser("user-1", {}, null)
-
-		expect(source).toBeDefined()
-		expect(source.id).toBe("freya.reminders")
-	})
-})

apps/freya-backend/src/reminders/provider.ts

@@ -1,48 +0,0 @@
-import { ReminderSource, ReminderTimeZoneInput } from "@freya/source-reminders"
-import { type } from "arktype"
-
-import type { Database } from "../db/index.ts"
-import type { FeedSourceProvider } from "../session/feed-source-provider.ts"
-
-import { DrizzleReminderStorage } from "./storage.ts"
-
-export interface ReminderSourceProviderOptions {
-	db: Database
-}
-
-export const reminderConfig = type({
-	"+": "reject",
-	"lookAheadMs?": "number.integer >= 0",
-	"lookBackMs?": "number.integer >= 0",
-	"includeCompleted?": "boolean",
-	"defaultTimeZone?": ReminderTimeZoneInput,
-})
-
-export class ReminderSourceProvider implements FeedSourceProvider {
-	readonly sourceId = "freya.reminders"
-	readonly configSchema = reminderConfig
-	private readonly db: Database
-
-	constructor(options: ReminderSourceProviderOptions) {
-		this.db = options.db
-	}
-
-	async feedSourceForUser(
-		userId: string,
-		config: unknown,
-		_credentials: unknown,
-	): Promise<ReminderSource> {
-		const parsed = reminderConfig(config)
-		if (parsed instanceof type.errors) {
-			throw new Error(`Invalid reminders config: ${parsed.summary}`)
-		}
-
-		return new ReminderSource({
-			storage: new DrizzleReminderStorage(this.db, userId),
-			lookAheadMs: parsed.lookAheadMs,
-			lookBackMs: parsed.lookBackMs,
-			includeCompleted: parsed.includeCompleted,
-			defaultTimeZone: parsed.defaultTimeZone,
-		})
-	}
-}

apps/freya-backend/src/reminders/storage.ts

@@ -1,276 +0,0 @@
-import type {
-	CreateReminderInput,
-	Reminder,
-	ReminderListParams,
-	ReminderOccurrenceOverride,
-	ReminderOccurrenceOverrideInput,
-	ReminderOccurrenceOverrideListParams,
-	ReminderOccurrencePatch,
-	ReminderPatch,
-	ReminderPriority,
-	ReminderRecurrence,
-	ReminderStorage,
-} from "@freya/source-reminders"
-
-import {
-	ReminderOccurrencePatchInput,
-	ReminderPriority as ReminderPriorityValue,
-	ReminderPriorityInput,
-	ReminderRecurrenceInput,
-} from "@freya/source-reminders"
-import { type } from "arktype"
-import { and, eq, inArray } from "drizzle-orm"
-
-import type { Database } from "../db/index.ts"
-
-import { reminderOccurrenceOverrides, reminders } from "../db/schema.ts"
-
-interface ArkSchema<T> {
-	(value: unknown): T | InstanceType<typeof type.errors>
-}
-
-type ReminderRow = typeof reminders.$inferSelect
-type ReminderInsert = typeof reminders.$inferInsert
-type ReminderOccurrenceOverrideRow = typeof reminderOccurrenceOverrides.$inferSelect
-type ReminderOccurrenceOverrideInsert = typeof reminderOccurrenceOverrides.$inferInsert
-
-export class DrizzleReminderStorage implements ReminderStorage {
-	private readonly db: Database
-	private readonly userId: string
-
-	constructor(db: Database, userId: string) {
-		this.db = db
-		this.userId = userId
-	}
-
-	async listReminders(_params: ReminderListParams): Promise<Reminder[]> {
-		const rows = await this.db.select().from(reminders).where(eq(reminders.userId, this.userId))
-
-		return rows.map(rowToReminder)
-	}
-
-	async getReminder(id: string): Promise<Reminder | null> {
-		const rows = await this.db
-			.select()
-			.from(reminders)
-			.where(and(eq(reminders.userId, this.userId), eq(reminders.id, id)))
-			.limit(1)
-
-		return rows[0] ? rowToReminder(rows[0]) : null
-	}
-
-	async createReminder(input: CreateReminderInput): Promise<Reminder> {
-		const rows = await this.db
-			.insert(reminders)
-			.values({
-				userId: this.userId,
-				title: input.title,
-				notes: input.notes ?? null,
-				dueAt: input.dueAt,
-				timeZone: input.timeZone ?? "UTC",
-				recurrence: serializeRecurrence(input.recurrence ?? null),
-				priority: input.priority ?? ReminderPriorityValue.Normal,
-			})
-			.returning()
-
-		return rowToReminder(requireRow(rows))
-	}
-
-	async updateReminder(id: string, patch: ReminderPatch): Promise<Reminder> {
-		const update: Partial<ReminderInsert> = { updatedAt: new Date() }
-
-		if (hasOwn(patch, "title")) update.title = patch.title
-		if (hasOwn(patch, "notes")) update.notes = patch.notes ?? null
-		if (hasOwn(patch, "dueAt")) update.dueAt = patch.dueAt
-		if (hasOwn(patch, "timeZone")) update.timeZone = patch.timeZone
-		if (hasOwn(patch, "recurrence")) update.recurrence = serializeRecurrence(patch.recurrence)
-		if (hasOwn(patch, "priority")) update.priority = patch.priority
-
-		const rows = await this.db
-			.update(reminders)
-			.set(update)
-			.where(and(eq(reminders.userId, this.userId), eq(reminders.id, id)))
-			.returning()
-
-		return rowToReminder(requireRow(rows, `Reminder not found: ${id}`))
-	}
-
-	async deleteReminder(id: string): Promise<void> {
-		await this.db
-			.delete(reminders)
-			.where(and(eq(reminders.userId, this.userId), eq(reminders.id, id)))
-	}
-
-	async listOccurrenceOverrides(
-		params: ReminderOccurrenceOverrideListParams,
-	): Promise<ReminderOccurrenceOverride[]> {
-		if (params.reminderIds.length === 0) return []
-
-		const rows = await this.db
-			.select()
-			.from(reminderOccurrenceOverrides)
-			.where(
-				and(
-					eq(reminderOccurrenceOverrides.userId, this.userId),
-					inArray(reminderOccurrenceOverrides.reminderId, [...params.reminderIds]),
-				),
-			)
-
-		return rows.map(rowToOccurrenceOverride)
-	}
-
-	async getOccurrenceOverride(
-		reminderId: string,
-		occurrenceId: string,
-	): Promise<ReminderOccurrenceOverride | null> {
-		const rows = await this.db
-			.select()
-			.from(reminderOccurrenceOverrides)
-			.where(
-				and(
-					eq(reminderOccurrenceOverrides.userId, this.userId),
-					eq(reminderOccurrenceOverrides.reminderId, reminderId),
-					eq(reminderOccurrenceOverrides.occurrenceId, occurrenceId),
-				),
-			)
-			.limit(1)
-
-		return rows[0] ? rowToOccurrenceOverride(rows[0]) : null
-	}
-
-	async upsertOccurrenceOverride(
-		input: ReminderOccurrenceOverrideInput,
-	): Promise<ReminderOccurrenceOverride> {
-		const values: ReminderOccurrenceOverrideInsert = {
-			userId: this.userId,
-			reminderId: input.reminderId,
-			occurrenceId: input.occurrenceId,
-			originalDueAt: input.originalDueAt,
-			patch: serializeOccurrencePatch(input.patch),
-			completedAt: input.completedAt ?? null,
-			deletedAt: input.deletedAt ?? null,
-		}
-
-		const rows = await this.db
-			.insert(reminderOccurrenceOverrides)
-			.values(values)
-			.onConflictDoUpdate({
-				target: [reminderOccurrenceOverrides.reminderId, reminderOccurrenceOverrides.occurrenceId],
-				set: {
-					originalDueAt: values.originalDueAt,
-					patch: values.patch,
-					completedAt: values.completedAt,
-					deletedAt: values.deletedAt,
-					updatedAt: new Date(),
-				},
-			})
-			.returning()
-
-		return rowToOccurrenceOverride(requireRow(rows))
-	}
-
-	async deleteOccurrenceOverride(reminderId: string, occurrenceId: string): Promise<void> {
-		await this.db
-			.delete(reminderOccurrenceOverrides)
-			.where(
-				and(
-					eq(reminderOccurrenceOverrides.userId, this.userId),
-					eq(reminderOccurrenceOverrides.reminderId, reminderId),
-					eq(reminderOccurrenceOverrides.occurrenceId, occurrenceId),
-				),
-			)
-	}
-}
-
-function rowToReminder(row: ReminderRow): Reminder {
-	return {
-		id: row.id,
-		title: row.title,
-		notes: row.notes,
-		dueAt: row.dueAt,
-		timeZone: row.timeZone,
-		recurrence: parseRecurrence(row.recurrence),
-		priority: assertSchema<ReminderPriority>(ReminderPriorityInput, row.priority),
-		createdAt: row.createdAt,
-		updatedAt: row.updatedAt,
-	}
-}
-
-function rowToOccurrenceOverride(row: ReminderOccurrenceOverrideRow): ReminderOccurrenceOverride {
-	return {
-		reminderId: row.reminderId,
-		occurrenceId: row.occurrenceId,
-		originalDueAt: row.originalDueAt,
-		patch: parseOccurrencePatch(row.patch),
-		completedAt: row.completedAt,
-		deletedAt: row.deletedAt,
-		createdAt: row.createdAt,
-		updatedAt: row.updatedAt,
-	}
-}
-
-function parseRecurrence(value: unknown): ReminderRecurrence | null {
-	if (value === null || value === undefined) return null
-	return assertSchema<ReminderRecurrence>(ReminderRecurrenceInput, value)
-}
-
-function parseOccurrencePatch(value: unknown): ReminderOccurrencePatch | undefined {
-	if (value === null || value === undefined) return undefined
-	return assertSchema<ReminderOccurrencePatch>(ReminderOccurrencePatchInput, value)
-}
-
-function serializeRecurrence(recurrence: ReminderRecurrence | null | undefined): unknown {
-	if (!recurrence) return null
-
-	const value: Record<string, unknown> = {
-		frequency: recurrence.frequency,
-		interval: recurrence.interval,
-	}
-
-	if (recurrence.weekdays !== undefined) value.weekdays = recurrence.weekdays
-	if (recurrence.count !== undefined) value.count = recurrence.count
-	if (recurrence.until !== undefined) value.until = recurrence.until.toISOString()
-
-	return value
-}
-
-function serializeOccurrencePatch(patch: ReminderOccurrencePatch | undefined): unknown {
-	if (!patch) return null
-
-	const value: Record<string, unknown> = {}
-	if (hasOwn(patch, "title")) value.title = patch.title
-	if (hasOwn(patch, "notes")) value.notes = patch.notes
-	if (hasOwn(patch, "dueAt") && patch.dueAt !== undefined) {
-		value.dueAt = patch.dueAt.toISOString()
-	}
-	if (hasOwn(patch, "timeZone")) value.timeZone = patch.timeZone
-	if (hasOwn(patch, "priority")) value.priority = patch.priority
-
-	return value
-}
-
-function requireRow<TRow>(
-	rows: TRow[],
-	message = "Reminder storage mutation returned no rows",
-): TRow {
-	const row = rows[0]
-	if (!row) {
-		throw new Error(message)
-	}
-	return row
-}
-
-function assertSchema<T>(schema: ArkSchema<T>, value: unknown): T {
-	const result = schema(value)
-	if (result instanceof type.errors) {
-		throw new Error(result.summary)
-	}
-	return result
-}
-
-function hasOwn<TObject extends object, TKey extends PropertyKey>(
-	object: TObject,
-	key: TKey,
-): object is TObject & Record<TKey, unknown> {
-	return Object.prototype.hasOwnProperty.call(object, key)
-}

apps/freya-backend/src/server.ts

@@ -11,11 +11,9 @@ import { createDatabase } from "./db/index.ts"
 import { registerFeedHttpHandlers } from "./engine/http.ts"
 import { createFeedEnhancer } from "./enhancement/enhance-feed.ts"
 import { createLlmClient } from "./enhancement/llm-client.ts"
-import { GoogleMapsSourceProvider } from "./google-maps/provider.ts"
 import { CredentialEncryptor } from "./lib/crypto.ts"
 import { registerLocationHttpHandlers } from "./location/http.ts"
 import { LocationSourceProvider } from "./location/provider.ts"
-import { ReminderSourceProvider } from "./reminders/provider.ts"
 import { UserSessionManager } from "./session/index.ts"
 import { registerSourcesHttpHandlers } from "./sources/http.ts"
 import { TflSourceProvider } from "./tfl/provider.ts"
@@ -49,17 +47,11 @@ function main() {
 		)
 	}
 
-	const googleMapsApiKey = process.env.GOOGLE_MAPS_API_KEY ?? process.env.GOOGLE_MAPS_MCP_API_KEY
-	if (!googleMapsApiKey) {
-		throw new Error("GOOGLE_MAPS_API_KEY or GOOGLE_MAPS_MCP_API_KEY must be set")
-	}
-
 	const sessionManager = new UserSessionManager({
 		db,
 		providers: [
 			new CalDavSourceProvider(),
 			new LocationSourceProvider(),
-			new ReminderSourceProvider({ db }),
 			new WeatherSourceProvider({
 				credentials: {
 					privateKey: process.env.WEATHERKIT_PRIVATE_KEY!,
@@ -70,9 +62,6 @@ function main() {
 			}),
 			new TflSourceProvider({ apiKey: process.env.TFL_API_KEY! }),
 			new WebSearchSourceProvider({ apiKey: process.env.EXA_API_KEY }),
-			new GoogleMapsSourceProvider({
-				apiKey: googleMapsApiKey,
-			}),
 		],
 		feedEnhancer,
 		credentialEncryptor,

bun.lock

@@ -53,9 +53,7 @@
         "@freya/core": "workspace:*",
         "@freya/source-caldav": "workspace:*",
         "@freya/source-google-calendar": "workspace:*",
-        "@freya/source-google-maps": "workspace:*",
         "@freya/source-location": "workspace:*",
-        "@freya/source-reminders": "workspace:*",
         "@freya/source-tfl": "workspace:*",
         "@freya/source-weatherkit": "workspace:*",
         "@freya/source-web-search": "workspace:*",
@@ -195,14 +193,6 @@
         "arktype": "^2.1.0",
       },
     },
-    "packages/freya-source-google-maps": {
-      "name": "@freya/source-google-maps",
-      "version": "0.0.0",
-      "dependencies": {
-        "@freya/source-mcp": "workspace:*",
-        "arktype": "^2.1.0",
-      },
-    },
     "packages/freya-source-location": {
       "name": "@freya/source-location",
       "version": "0.0.0",
@@ -219,19 +209,6 @@
         "@modelcontextprotocol/sdk": "^1.27.1",
       },
     },
-    "packages/freya-source-reminders": {
-      "name": "@freya/source-reminders",
-      "version": "0.0.0",
-      "dependencies": {
-        "@freya/components": "workspace:*",
-        "@freya/core": "workspace:*",
-        "arktype": "^2.1.0",
-      },
-      "peerDependencies": {
-        "@json-render/core": "*",
-        "@nym.sh/jrx": "*",
-      },
-    },
     "packages/freya-source-tfl": {
       "name": "@freya/source-tfl",
       "version": "0.0.0",
@@ -695,12 +672,8 @@
 
     "@freya/source-google-calendar": ["@freya/source-google-calendar@workspace:packages/freya-source-google-calendar"],
 
-    "@freya/source-google-maps": ["@freya/source-google-maps@workspace:packages/freya-source-google-maps"],
-
     "@freya/source-location": ["@freya/source-location@workspace:packages/freya-source-location"],
 
-    "@freya/source-reminders": ["@freya/source-reminders@workspace:packages/freya-source-reminders"],
-
     "@freya/source-tfl": ["@freya/source-tfl@workspace:packages/freya-source-tfl"],
 
     "@freya/source-weatherkit": ["@freya/source-weatherkit@workspace:packages/freya-source-weatherkit"],

packages/freya-source-google-maps/package.json

@@ -1,14 +0,0 @@
-{
-	"name": "@freya/source-google-maps",
-	"version": "0.0.0",
-	"type": "module",
-	"main": "src/index.ts",
-	"types": "src/index.ts",
-	"scripts": {
-		"test": "bun test src/"
-	},
-	"dependencies": {
-		"@freya/source-mcp": "workspace:*",
-		"arktype": "^2.1.0"
-	}
-}

packages/freya-source-google-maps/src/google-maps-source.test.ts

@@ -1,135 +0,0 @@
-import type {
-	McpCallToolParams,
-	McpCallToolResult,
-	McpClient,
-	McpListToolsResult,
-	McpReadResourceParams,
-	McpReadResourceResult,
-} from "@freya/source-mcp"
-
-import { describe, expect, test } from "bun:test"
-
-import { GoogleMapsAction, GoogleMapsSource, GoogleMapsSourceId, GoogleMapsTool } from "./index"
-
-class MockMcpClient implements McpClient {
-	readonly calls: McpCallToolParams[] = []
-
-	async listTools(): Promise<McpListToolsResult> {
-		return {
-			tools: Object.values(GoogleMapsTool).map((name) => ({
-				name,
-				description: `${name} description`,
-			})),
-		}
-	}
-
-	async readResource(_params: McpReadResourceParams): Promise<McpReadResourceResult> {
-		throw new Error("unexpected resource read")
-	}
-
-	async callTool(params: McpCallToolParams): Promise<McpCallToolResult> {
-		this.calls.push(params)
-		return {
-			structuredContent: {
-				tool: params.name,
-				arguments: params.arguments ?? {},
-			},
-		}
-	}
-}
-
-describe("GoogleMapsSource", () => {
-	test("uses the Google Maps source id", () => {
-		const source = new GoogleMapsSource({ client: new MockMcpClient() })
-		expect(source.id).toBe(GoogleMapsSourceId)
-	})
-
-	test("exposes documented Google Maps MCP tools as actions", async () => {
-		const source = new GoogleMapsSource({ client: new MockMcpClient() })
-
-		const actions = await source.listActions()
-
-		expect(Object.keys(actions).sort()).toEqual(Object.values(GoogleMapsAction).sort())
-		expect(actions[GoogleMapsAction.SearchPlaces]!.id).toBe(GoogleMapsAction.SearchPlaces)
-	})
-
-	test("maps action execution to the underlying MCP tool", async () => {
-		const client = new MockMcpClient()
-		const source = new GoogleMapsSource({ client })
-
-		const result = await source.executeAction(GoogleMapsAction.SearchPlaces, {
-			textQuery: "coffee shops near Golden Gate Park",
-			regionCode: "US",
-		})
-
-		expect(client.calls).toEqual([
-			{
-				name: GoogleMapsTool.SearchPlaces,
-				arguments: {
-					textQuery: "coffee shops near Golden Gate Park",
-					regionCode: "US",
-				},
-			},
-		])
-		expect(result).toEqual({
-			tool: GoogleMapsTool.SearchPlaces,
-			arguments: {
-				textQuery: "coffee shops near Golden Gate Park",
-				regionCode: "US",
-			},
-		})
-	})
-
-	test("validates action input before calling the MCP tool", async () => {
-		const client = new MockMcpClient()
-		const source = new GoogleMapsSource({ client })
-
-		await expectRejectsWithMessage(
-			source.executeAction(GoogleMapsAction.SearchPlaces, {}),
-			"textQuery must be a string",
-		)
-		expect(client.calls).toEqual([])
-	})
-
-	test("validates resolve names query objects", async () => {
-		const client = new MockMcpClient()
-		const source = new GoogleMapsSource({ client })
-
-		await expectRejectsWithMessage(
-			source.executeAction(GoogleMapsAction.ResolveNames, { queries: [{}] }),
-			"queries[0].text must be a string",
-		)
-		expect(client.calls).toEqual([])
-	})
-
-	test("does not produce feed items or context by default", async () => {
-		const source = new GoogleMapsSource({ client: new MockMcpClient() })
-
-		const contextEntries = await source.fetchContext(undefined as never)
-		const items = await source.fetchItems(undefined as never)
-
-		expect(contextEntries).toBeNull()
-		expect(items).toEqual([])
-	})
-})
-
-async function expectRejectsWithMessage(
-	promise: Promise<unknown>,
-	expectedMessage: string,
-): Promise<void> {
-	try {
-		await promise
-	} catch (err) {
-		expect(errorMessage(err)).toContain(expectedMessage)
-		return
-	}
-
-	throw new Error(`Expected promise to reject with "${expectedMessage}"`)
-}
-
-function errorMessage(err: unknown): string {
-	if (err instanceof Error) {
-		return err.message
-	}
-	return String(err)
-}

packages/freya-source-google-maps/src/google-maps-source.ts

@@ -1,151 +0,0 @@
-import {
-	McpSource,
-	type McpActionMapping,
-	type McpClient,
-	type McpHttpHeaders,
-	type McpSourceOptions,
-} from "@freya/source-mcp"
-
-import {
-	ComputeRoutesInput,
-	LookupWeatherInput,
-	ResolveMapsUrlsInput,
-	ResolveNamesInput,
-	SearchPlacesInput,
-} from "./schemas"
-
-export type GoogleMapsApiKey = string | (() => Promise<string>)
-
-export interface GoogleMapsSourceOptions {
-	readonly endpoint?: string | URL
-	readonly apiKey?: GoogleMapsApiKey
-	readonly timeoutMs?: number
-	readonly headers?: McpHttpHeaders | (() => Promise<McpHttpHeaders>)
-	readonly requestInit?: RequestInit
-	readonly transportOptions?: McpSourceOptions["transportOptions"]
-	readonly client?: McpClient
-	readonly clientFactory?: McpSourceOptions["clientFactory"]
-}
-
-export const GoogleMapsSourceId = "freya.google-maps"
-
-export const GoogleMapsMcpEndpoint = "https://mapstools.googleapis.com/mcp"
-
-export const GoogleMapsAction = {
-	SearchPlaces: "search-places",
-	LookupWeather: "lookup-weather",
-	ComputeRoutes: "compute-routes",
-	ResolveNames: "resolve-names",
-	ResolveMapsUrls: "resolve-maps-urls",
-} as const
-
-export type GoogleMapsAction = (typeof GoogleMapsAction)[keyof typeof GoogleMapsAction]
-
-export const GoogleMapsTool = {
-	SearchPlaces: "search_places",
-	LookupWeather: "lookup_weather",
-	ComputeRoutes: "compute_routes",
-	ResolveNames: "resolve_names",
-	ResolveMapsUrls: "resolve_maps_urls",
-} as const
-
-export type GoogleMapsTool = (typeof GoogleMapsTool)[keyof typeof GoogleMapsTool]
-
-const GoogleMapsActions = {
-	[GoogleMapsAction.SearchPlaces]: {
-		tool: GoogleMapsTool.SearchPlaces,
-		description:
-			"Find places, businesses, addresses, locations, and points of interest with Google Maps.",
-		input: SearchPlacesInput,
-	},
-	[GoogleMapsAction.LookupWeather]: {
-		tool: GoogleMapsTool.LookupWeather,
-		description: "Retrieve current conditions and weather forecasts through Google Maps.",
-		input: LookupWeatherInput,
-	},
-	[GoogleMapsAction.ComputeRoutes]: {
-		tool: GoogleMapsTool.ComputeRoutes,
-		description: "Compute a Google Maps route between an origin and destination.",
-		input: ComputeRoutesInput,
-	},
-	[GoogleMapsAction.ResolveNames]: {
-		tool: GoogleMapsTool.ResolveNames,
-		description: "Resolve specific place names or addresses into Google Maps Place IDs.",
-		input: ResolveNamesInput,
-	},
-	[GoogleMapsAction.ResolveMapsUrls]: {
-		tool: GoogleMapsTool.ResolveMapsUrls,
-		description: "Resolve Google Maps URLs into canonical Google Maps Place IDs.",
-		input: ResolveMapsUrlsInput,
-	},
-} as const satisfies Record<GoogleMapsAction, McpActionMapping>
-
-export class GoogleMapsSource extends McpSource {
-	constructor(options: GoogleMapsSourceOptions = {}) {
-		super({
-			id: GoogleMapsSourceId,
-			url: options.endpoint ?? GoogleMapsMcpEndpoint,
-			clientName: "freya-source-google-maps",
-			clientVersion: "0.0.0",
-			timeoutMs: options.timeoutMs,
-			headers: createGoogleMapsHeaders({
-				headers: options.headers,
-				apiKey: options.apiKey,
-			}),
-			requestInit: options.requestInit,
-			transportOptions: options.transportOptions,
-			client: options.client,
-			clientFactory: options.clientFactory,
-			actions: GoogleMapsActions,
-		})
-	}
-}
-
-interface GoogleMapsHeaderOptions {
-	readonly headers: McpHttpHeaders | (() => Promise<McpHttpHeaders>) | undefined
-	readonly apiKey: GoogleMapsApiKey | undefined
-}
-
-function createGoogleMapsHeaders({
-	headers,
-	apiKey,
-}: GoogleMapsHeaderOptions): McpHttpHeaders | (() => Promise<McpHttpHeaders>) | undefined {
-	if (!apiKey) {
-		return headers
-	}
-
-	return async () => {
-		const merged = new Headers()
-		const resolvedHeaders = typeof headers === "function" ? await headers() : headers
-		if (resolvedHeaders) {
-			applyHeaders(merged, resolvedHeaders)
-		}
-
-		if (apiKey) {
-			const resolvedApiKey = typeof apiKey === "function" ? await apiKey() : apiKey
-			merged.set("x-goog-api-key", resolvedApiKey)
-		}
-
-		return merged
-	}
-}
-
-function applyHeaders(target: Headers, headers: McpHttpHeaders): void {
-	if (headers instanceof Headers) {
-		headers.forEach((value, key) => {
-			target.set(key, value)
-		})
-		return
-	}
-
-	if (Array.isArray(headers)) {
-		for (const [key, value] of headers) {
-			target.set(key, value)
-		}
-		return
-	}
-
-	for (const [key, value] of Object.entries(headers)) {
-		target.set(key, value)
-	}
-}

packages/freya-source-google-maps/src/index.ts

@@ -1,17 +0,0 @@
-export {
-	GoogleMapsAction,
-	GoogleMapsMcpEndpoint,
-	GoogleMapsSource,
-	GoogleMapsSourceId,
-	GoogleMapsTool,
-	type GoogleMapsApiKey,
-	type GoogleMapsSourceOptions,
-} from "./google-maps-source"
-
-export {
-	ComputeRoutesInput,
-	LookupWeatherInput,
-	ResolveMapsUrlsInput,
-	ResolveNamesInput,
-	SearchPlacesInput,
-} from "./schemas"

packages/freya-source-google-maps/src/schemas.ts

@@ -1,41 +0,0 @@
-import { type } from "arktype"
-
-const ResolveNameQuery = type({
-	"+": "reject",
-	text: "string",
-})
-
-export const SearchPlacesInput = type({
-	"+": "reject",
-	textQuery: "string",
-	"locationBias?": "unknown",
-	"languageCode?": "string",
-	"regionCode?": "string",
-})
-
-export const LookupWeatherInput = type({
-	"+": "reject",
-	location: "unknown",
-	"date?": "unknown",
-	"hour?": "number",
-	"unitsSystem?": "'UNITS_SYSTEM_UNSPECIFIED' | 'METRIC' | 'IMPERIAL'",
-})
-
-export const ComputeRoutesInput = type({
-	"+": "reject",
-	origin: "unknown",
-	destination: "unknown",
-	"travelMode?": "'ROUTE_TRAVEL_MODE_UNSPECIFIED' | 'DRIVE' | 'WALK'",
-})
-
-export const ResolveNamesInput = type({
-	"+": "reject",
-	queries: ResolveNameQuery.array(),
-	"locationBias?": "unknown",
-	"regionCode?": "string",
-})
-
-export const ResolveMapsUrlsInput = type({
-	"+": "reject",
-	urls: "string[]",
-})

packages/freya-source-google-maps/tsconfig.json

@@ -1,4 +0,0 @@
-{
-	"extends": "../../tsconfig.json",
-	"include": ["src"]
-}

packages/freya-source-reminders/package.json

@@ -1,19 +0,0 @@
-{
-	"name": "@freya/source-reminders",
-	"version": "0.0.0",
-	"type": "module",
-	"main": "src/index.ts",
-	"types": "src/index.ts",
-	"scripts": {
-		"test": "bun test src/"
-	},
-	"dependencies": {
-		"@freya/components": "workspace:*",
-		"@freya/core": "workspace:*",
-		"arktype": "^2.1.0"
-	},
-	"peerDependencies": {
-		"@json-render/core": "*",
-		"@nym.sh/jrx": "*"
-	}
-}

packages/freya-source-reminders/src/index.ts

@@ -1,11 +0,0 @@
-export { ReminderSource, type ReminderSourceOptions } from "./reminder-source.ts"
-export {
-	createReminderOccurrenceId,
-	expandReminderOccurrences,
-	expandReminderOriginalDueAts,
-	findReminderOccurrenceIndex,
-	recurrenceAfterSplit,
-	stopRecurrenceAfterOccurrenceCount,
-} from "./recurrence.ts"
-export { renderReminderFeedItem } from "./renderer.tsx"
-export * from "./types.ts"

packages/freya-source-reminders/src/recurrence.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-import type { Reminder } from "./types.ts"
-
-import { expandReminderOriginalDueAts, findReminderOccurrenceIndex } from "./recurrence.ts"
-import { ReminderPriority, ReminderRecurrenceFrequency, ReminderWeekday } from "./types.ts"
-
-describe("recurrence", () => {
-	test("deduplicates weekly weekdays before applying recurrence count", () => {
-		const reminder = weeklyReminder({
-			recurrence: {
-				frequency: ReminderRecurrenceFrequency.Weekly,
-				interval: 1,
-				weekdays: [ReminderWeekday.Monday, ReminderWeekday.Monday, ReminderWeekday.Wednesday],
-				count: 3,
-			},
-		})
-
-		const originalDueAts = expandReminderOriginalDueAts(
-			reminder,
-			new Date("2026-06-08T00:00:00Z"),
-			new Date("2026-06-22T00:00:00Z"),
-		)
-
-		expect(originalDueAts.map(toIsoString)).toEqual([
-			"2026-06-08T09:00:00.000Z",
-			"2026-06-10T09:00:00.000Z",
-			"2026-06-15T09:00:00.000Z",
-		])
-	})
-
-	test("deduplicates weekly weekdays before calculating occurrence indexes", () => {
-		const reminder = weeklyReminder({
-			recurrence: {
-				frequency: ReminderRecurrenceFrequency.Weekly,
-				interval: 1,
-				weekdays: [ReminderWeekday.Monday, ReminderWeekday.Monday, ReminderWeekday.Wednesday],
-			},
-		})
-
-		expect(findReminderOccurrenceIndex(reminder, new Date("2026-06-10T09:00:00Z"))).toBe(1)
-		expect(findReminderOccurrenceIndex(reminder, new Date("2026-06-15T09:00:00Z"))).toBe(2)
-	})
-})
-
-function weeklyReminder(overrides: Partial<Reminder> = {}): Reminder {
-	const now = new Date("2026-06-01T00:00:00Z")
-	return {
-		id: "r1",
-		title: "Take vitamins",
-		notes: null,
-		dueAt: new Date("2026-06-08T09:00:00Z"),
-		timeZone: "UTC",
-		recurrence: {
-			frequency: ReminderRecurrenceFrequency.Weekly,
-			interval: 1,
-			weekdays: [ReminderWeekday.Monday],
-		},
-		priority: ReminderPriority.Normal,
-		createdAt: now,
-		updatedAt: now,
-		...overrides,
-	}
-}
-
-function toIsoString(date: Date): string {
-	return date.toISOString()
-}

packages/freya-source-reminders/src/recurrence.ts

@@ -1,392 +0,0 @@
-import type {
-	Reminder,
-	ReminderOccurrence,
-	ReminderOccurrenceOverride,
-	ReminderOccurrencePatch,
-	ReminderRecurrence,
-	ReminderWeekday,
-} from "./types.ts"
-
-import { ReminderRecurrenceFrequency } from "./types.ts"
-
-interface ZonedDateTimeParts {
-	year: number
-	month: number
-	day: number
-	hour: number
-	minute: number
-	second: number
-	millisecond: number
-}
-
-interface ExpandReminderOccurrencesOptions {
-	from: Date
-	to: Date
-	includeCompleted: boolean
-	overrides?: readonly ReminderOccurrenceOverride[]
-}
-
-export function createReminderOccurrenceId(originalDueAt: Date): string {
-	return originalDueAt.toISOString()
-}
-
-export function expandReminderOccurrences(
-	reminder: Reminder,
-	options: ExpandReminderOccurrencesOptions,
-): ReminderOccurrence[] {
-	const originalDueAts = new Map<string, Date>()
-	for (const dueAt of expandReminderOriginalDueAts(reminder, options.from, options.to)) {
-		originalDueAts.set(createReminderOccurrenceId(dueAt), dueAt)
-	}
-
-	const overrideById = new Map<string, ReminderOccurrenceOverride>()
-	for (const override of options.overrides ?? []) {
-		if (override.reminderId !== reminder.id) continue
-		if (!isCurrentOriginalDueAt(reminder, override.originalDueAt)) continue
-		overrideById.set(override.occurrenceId, override)
-		originalDueAts.set(override.occurrenceId, override.originalDueAt)
-	}
-
-	const occurrences: ReminderOccurrence[] = []
-	const originals = Array.from(originalDueAts.values()).sort(compareDates)
-
-	for (const originalDueAt of originals) {
-		const occurrenceId = createReminderOccurrenceId(originalDueAt)
-		const override = overrideById.get(occurrenceId)
-		if (override?.deletedAt) continue
-
-		const occurrence = createOccurrence(reminder, originalDueAt, override)
-		if (occurrence.dueAt < options.from || occurrence.dueAt > options.to) continue
-		if (!options.includeCompleted && occurrence.completedAt) continue
-
-		occurrences.push(occurrence)
-	}
-
-	return occurrences.sort(compareOccurrences)
-}
-
-export function expandReminderOriginalDueAts(reminder: Reminder, from: Date, to: Date): Date[] {
-	if (to < reminder.dueAt) return []
-
-	if (!reminder.recurrence) {
-		return reminder.dueAt >= from && reminder.dueAt <= to ? [reminder.dueAt] : []
-	}
-
-	switch (reminder.recurrence.frequency) {
-		case ReminderRecurrenceFrequency.Daily:
-			return expandDaily(reminder, from, to)
-		case ReminderRecurrenceFrequency.Weekly:
-			return expandWeekly(reminder, from, to)
-		case ReminderRecurrenceFrequency.Monthly:
-			return expandMonthly(reminder, from, to)
-		case ReminderRecurrenceFrequency.Yearly:
-			return expandYearly(reminder, from, to)
-	}
-}
-
-export function findReminderOccurrenceIndex(
-	reminder: Reminder,
-	occurrenceDueAt: Date,
-): number | null {
-	if (!reminder.recurrence) {
-		return reminder.dueAt.getTime() === occurrenceDueAt.getTime() ? 0 : null
-	}
-
-	const originals = expandReminderOriginalDueAts(reminder, reminder.dueAt, occurrenceDueAt)
-	for (let index = 0; index < originals.length; index++) {
-		if (originals[index]!.getTime() === occurrenceDueAt.getTime()) {
-			return index
-		}
-	}
-
-	return null
-}
-
-function isCurrentOriginalDueAt(reminder: Reminder, originalDueAt: Date): boolean {
-	return findReminderOccurrenceIndex(reminder, originalDueAt) !== null
-}
-
-export function stopRecurrenceAfterOccurrenceCount(
-	recurrence: ReminderRecurrence,
-	count: number,
-): ReminderRecurrence | null {
-	if (count <= 0) return null
-	return { ...recurrence, count }
-}
-
-export function recurrenceAfterSplit(
-	recurrence: ReminderRecurrence,
-	occurrenceIndex: number,
-): ReminderRecurrence | null {
-	if (recurrence.count === undefined) {
-		return { ...recurrence }
-	}
-
-	const remainingCount = recurrence.count - occurrenceIndex
-	if (remainingCount <= 1) return null
-
-	return { ...recurrence, count: remainingCount }
-}
-
-function expandDaily(reminder: Reminder, from: Date, to: Date): Date[] {
-	return expandStepped(reminder, from, to, function addDaily(parts, step) {
-		return addDays(parts, step)
-	})
-}
-
-function expandMonthly(reminder: Reminder, from: Date, to: Date): Date[] {
-	const anchor = getZonedParts(reminder.dueAt, reminder.timeZone).day
-	return expandStepped(reminder, from, to, function addMonthly(parts, step) {
-		return addMonths(parts, step, anchor)
-	})
-}
-
-function expandYearly(reminder: Reminder, from: Date, to: Date): Date[] {
-	const anchor = getZonedParts(reminder.dueAt, reminder.timeZone).day
-	return expandStepped(reminder, from, to, function addYearly(parts, step) {
-		return addMonths(parts, step * 12, anchor)
-	})
-}
-
-function expandStepped(
-	reminder: Reminder,
-	from: Date,
-	to: Date,
-	addStep: (parts: ZonedDateTimeParts, step: number) => ZonedDateTimeParts,
-): Date[] {
-	const recurrence = reminder.recurrence
-	if (!recurrence) return []
-
-	const dates: Date[] = []
-	const start = getZonedParts(reminder.dueAt, reminder.timeZone)
-	let emitted = 0
-	let index = 0
-
-	while (true) {
-		const parts = addStep(start, index * recurrence.interval)
-		const dueAt = zonedPartsToDate(parts, reminder.timeZone)
-		if (isAfterRecurrenceEnd(dueAt, recurrence, emitted)) break
-		if (dueAt > to) break
-
-		if (dueAt >= from) {
-			dates.push(dueAt)
-		}
-
-		emitted++
-		index++
-	}
-
-	return dates
-}
-
-function expandWeekly(reminder: Reminder, from: Date, to: Date): Date[] {
-	const recurrence = reminder.recurrence
-	if (!recurrence) return []
-
-	const start = getZonedParts(reminder.dueAt, reminder.timeZone)
-	const startWeekday = weekdayForParts(start)
-	const weekStart = addDays(start, -startWeekday)
-	const weekdays = recurrence.weekdays?.length
-		? Array.from(new Set(recurrence.weekdays)).sort(compareNumbers)
-		: [startWeekday as ReminderWeekday]
-
-	const dates: Date[] = []
-	let emitted = 0
-	let weekIndex = 0
-
-	while (true) {
-		let weekHadFutureDate = false
-
-		for (const weekday of weekdays) {
-			const parts = addDays(weekStart, weekIndex * recurrence.interval * 7 + weekday)
-			const dueAt = zonedPartsToDate(parts, reminder.timeZone)
-			if (dueAt < reminder.dueAt) continue
-			if (isAfterRecurrenceEnd(dueAt, recurrence, emitted)) return dates
-			if (dueAt > to) {
-				weekHadFutureDate = true
-				continue
-			}
-
-			if (dueAt >= from) {
-				dates.push(dueAt)
-			}
-
-			emitted++
-		}
-
-		if (weekHadFutureDate) break
-		weekIndex++
-	}
-
-	return dates.sort(compareDates)
-}
-
-function createOccurrence(
-	reminder: Reminder,
-	originalDueAt: Date,
-	override: ReminderOccurrenceOverride | undefined,
-): ReminderOccurrence {
-	const patch = override?.patch
-
-	return {
-		reminderId: reminder.id,
-		occurrenceId: createReminderOccurrenceId(originalDueAt),
-		title: patch?.title ?? reminder.title,
-		notes: valueWithNullableOverride(reminder.notes, patch, "notes"),
-		originalDueAt,
-		dueAt: patch?.dueAt ?? originalDueAt,
-		timeZone: patch?.timeZone ?? reminder.timeZone,
-		recurrence: reminder.recurrence,
-		priority: patch?.priority ?? reminder.priority,
-		completedAt: override?.completedAt ?? null,
-	}
-}
-
-function valueWithNullableOverride(
-	fallback: string | null,
-	patch: ReminderOccurrencePatch | undefined,
-	key: "notes",
-): string | null {
-	if (!patch) return fallback
-	if (Object.prototype.hasOwnProperty.call(patch, key)) {
-		return patch[key] ?? null
-	}
-	return fallback
-}
-
-function isAfterRecurrenceEnd(
-	dueAt: Date,
-	recurrence: ReminderRecurrence,
-	emittedCount: number,
-): boolean {
-	if (recurrence.count !== undefined && emittedCount >= recurrence.count) {
-		return true
-	}
-	if (recurrence.until !== undefined && dueAt > recurrence.until) {
-		return true
-	}
-	return false
-}
-
-function getZonedParts(date: Date, timeZone: string): ZonedDateTimeParts {
-	const formatter = new Intl.DateTimeFormat("en-US", {
-		timeZone,
-		year: "numeric",
-		month: "2-digit",
-		day: "2-digit",
-		hour: "2-digit",
-		minute: "2-digit",
-		second: "2-digit",
-		hourCycle: "h23",
-	})
-
-	const parts = formatter.formatToParts(date)
-	return {
-		year: numberPart(parts, "year"),
-		month: numberPart(parts, "month"),
-		day: numberPart(parts, "day"),
-		hour: numberPart(parts, "hour"),
-		minute: numberPart(parts, "minute"),
-		second: numberPart(parts, "second"),
-		millisecond: date.getUTCMilliseconds(),
-	}
-}
-
-function zonedPartsToDate(parts: ZonedDateTimeParts, timeZone: string): Date {
-	const localAsUtc = Date.UTC(
-		parts.year,
-		parts.month - 1,
-		parts.day,
-		parts.hour,
-		parts.minute,
-		parts.second,
-		parts.millisecond,
-	)
-	let timestamp = localAsUtc
-
-	for (let i = 0; i < 3; i++) {
-		const offset = getTimeZoneOffsetMs(new Date(timestamp), timeZone)
-		const next = localAsUtc - offset
-		if (next === timestamp) break
-		timestamp = next
-	}
-
-	return new Date(timestamp)
-}
-
-function getTimeZoneOffsetMs(date: Date, timeZone: string): number {
-	const parts = getZonedParts(date, timeZone)
-	const zonedAsUtc = Date.UTC(
-		parts.year,
-		parts.month - 1,
-		parts.day,
-		parts.hour,
-		parts.minute,
-		parts.second,
-		parts.millisecond,
-	)
-
-	return zonedAsUtc - date.getTime()
-}
-
-function numberPart(parts: Intl.DateTimeFormatPart[], type: Intl.DateTimeFormatPartTypes): number {
-	const part = parts.find(function matchesType(value) {
-		return value.type === type
-	})
-	if (!part) {
-		throw new Error(`Missing ${type} part while formatting zoned date`)
-	}
-	return Number(part.value)
-}
-
-function addDays(parts: ZonedDateTimeParts, days: number): ZonedDateTimeParts {
-	const date = new Date(Date.UTC(parts.year, parts.month - 1, parts.day + days))
-	return {
-		...parts,
-		year: date.getUTCFullYear(),
-		month: date.getUTCMonth() + 1,
-		day: date.getUTCDate(),
-	}
-}
-
-function addMonths(
-	parts: ZonedDateTimeParts,
-	months: number,
-	anchorDay: number,
-): ZonedDateTimeParts {
-	const monthIndex = parts.year * 12 + parts.month - 1 + months
-	const year = Math.floor(monthIndex / 12)
-	const month = positiveModulo(monthIndex, 12) + 1
-	const day = Math.min(anchorDay, daysInMonth(year, month))
-
-	return {
-		...parts,
-		year,
-		month,
-		day,
-	}
-}
-
-function daysInMonth(year: number, month: number): number {
-	return new Date(Date.UTC(year, month, 0)).getUTCDate()
-}
-
-function weekdayForParts(parts: ZonedDateTimeParts): number {
-	return new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay()
-}
-
-function positiveModulo(value: number, divisor: number): number {
-	return ((value % divisor) + divisor) % divisor
-}
-
-function compareDates(a: Date, b: Date): number {
-	return a.getTime() - b.getTime()
-}
-
-function compareNumbers(a: number, b: number): number {
-	return a - b
-}
-
-function compareOccurrences(a: ReminderOccurrence, b: ReminderOccurrence): number {
-	return a.dueAt.getTime() - b.dueAt.getTime()
-}

packages/freya-source-reminders/src/reminder-source.test.ts

@@ -1,706 +0,0 @@
-import { Context, TimeRelevance } from "@freya/core"
-import { describe, expect, mock, test } from "bun:test"
-
-import type {
-	CreateReminderInput,
-	Reminder,
-	ReminderListParams,
-	ReminderOccurrenceOverride,
-	ReminderOccurrenceOverrideInput,
-	ReminderOccurrenceOverrideListParams,
-	ReminderPatch,
-	ReminderStorage,
-} from "./types.ts"
-
-import { ReminderSource } from "./reminder-source.ts"
-import {
-	ReminderAction,
-	ReminderEditScope,
-	ReminderPriority,
-	ReminderRecurrenceFrequency,
-	ReminderUpdateResultType,
-	ReminderWeekday,
-} from "./types.ts"
-
-class InMemoryReminderStorage implements ReminderStorage {
-	readonly reminders = new Map<string, Reminder>()
-	readonly overrides = new Map<string, ReminderOccurrenceOverride>()
-	private nextId = 1
-	private readonly listeners = new Set<() => void>()
-
-	constructor(reminders: Reminder[] = []) {
-		for (const reminder of reminders) {
-			this.reminders.set(reminder.id, reminder)
-		}
-	}
-
-	async listReminders(_params: ReminderListParams): Promise<Reminder[]> {
-		return Array.from(this.reminders.values())
-	}
-
-	async getReminder(id: string): Promise<Reminder | null> {
-		return this.reminders.get(id) ?? null
-	}
-
-	async createReminder(input: CreateReminderInput): Promise<Reminder> {
-		const now = new Date("2026-06-01T00:00:00Z")
-		const reminder: Reminder = {
-			id: `reminder-${this.nextId++}`,
-			title: input.title,
-			notes: input.notes ?? null,
-			dueAt: input.dueAt,
-			timeZone: input.timeZone ?? "UTC",
-			recurrence: input.recurrence ?? null,
-			priority: input.priority ?? ReminderPriority.Normal,
-			createdAt: now,
-			updatedAt: now,
-		}
-
-		this.reminders.set(reminder.id, reminder)
-		this.notify()
-		return reminder
-	}
-
-	async updateReminder(id: string, patch: ReminderPatch): Promise<Reminder> {
-		const existing = this.reminders.get(id)
-		if (!existing) {
-			throw new Error(`Reminder not found: ${id}`)
-		}
-
-		const updated: Reminder = {
-			...existing,
-			updatedAt: new Date("2026-06-01T00:01:00Z"),
-		}
-		if (hasOwn(patch, "title")) updated.title = patch.title
-		if (hasOwn(patch, "notes")) updated.notes = patch.notes ?? null
-		if (hasOwn(patch, "dueAt")) updated.dueAt = patch.dueAt
-		if (hasOwn(patch, "timeZone")) updated.timeZone = patch.timeZone
-		if (hasOwn(patch, "recurrence")) updated.recurrence = patch.recurrence ?? null
-		if (hasOwn(patch, "priority")) updated.priority = patch.priority
-
-		this.reminders.set(id, updated)
-		this.notify()
-		return updated
-	}
-
-	async deleteReminder(id: string): Promise<void> {
-		this.reminders.delete(id)
-		this.notify()
-	}
-
-	async listOccurrenceOverrides(
-		params: ReminderOccurrenceOverrideListParams,
-	): Promise<ReminderOccurrenceOverride[]> {
-		const reminderIds = new Set(params.reminderIds)
-		return Array.from(this.overrides.values()).filter(function matches(override) {
-			if (!reminderIds.has(override.reminderId)) return false
-			const dueAt = override.patch?.dueAt ?? override.originalDueAt
-			return (
-				isWithin(override.originalDueAt, params.from, params.to) ||
-				isWithin(dueAt, params.from, params.to)
-			)
-		})
-	}
-
-	async getOccurrenceOverride(
-		reminderId: string,
-		occurrenceId: string,
-	): Promise<ReminderOccurrenceOverride | null> {
-		return this.overrides.get(overrideKey(reminderId, occurrenceId)) ?? null
-	}
-
-	async upsertOccurrenceOverride(
-		input: ReminderOccurrenceOverrideInput,
-	): Promise<ReminderOccurrenceOverride> {
-		const existing = this.overrides.get(overrideKey(input.reminderId, input.occurrenceId))
-		const now = new Date("2026-06-01T00:02:00Z")
-		const override: ReminderOccurrenceOverride = {
-			...existing,
-			...input,
-			createdAt: existing?.createdAt ?? now,
-			updatedAt: now,
-		}
-
-		this.overrides.set(overrideKey(input.reminderId, input.occurrenceId), override)
-		this.notify()
-		return override
-	}
-
-	async deleteOccurrenceOverride(reminderId: string, occurrenceId: string): Promise<void> {
-		this.overrides.delete(overrideKey(reminderId, occurrenceId))
-		this.notify()
-	}
-
-	subscribe(callback: () => void): () => void {
-		this.listeners.add(callback)
-		return () => {
-			this.listeners.delete(callback)
-		}
-	}
-
-	private notify(): void {
-		for (const listener of this.listeners) {
-			listener()
-		}
-	}
-}
-
-function reminder(overrides: Partial<Reminder> = {}): Reminder {
-	const now = new Date("2026-06-01T00:00:00Z")
-	return {
-		id: "r1",
-		title: "Take vitamins",
-		notes: null,
-		dueAt: new Date("2026-06-12T09:00:00Z"),
-		timeZone: "UTC",
-		recurrence: null,
-		priority: ReminderPriority.Normal,
-		createdAt: now,
-		updatedAt: now,
-		...overrides,
-	}
-}
-
-function context(time: string): Context {
-	return new Context(new Date(time))
-}
-
-function overrideKey(reminderId: string, occurrenceId: string): string {
-	return `${reminderId}:${occurrenceId}`
-}
-
-function isWithin(date: Date, from: Date, to: Date): boolean {
-	return date >= from && date <= to
-}
-
-function hasOwn<TObject extends object, TKey extends keyof TObject>(
-	object: TObject,
-	key: TKey,
-): object is TObject & Required<Pick<TObject, TKey>> {
-	return Object.prototype.hasOwnProperty.call(object, key)
-}
-
-describe("ReminderSource", () => {
-	describe("FeedSource interface", () => {
-		test("has correct id and actions", async () => {
-			const source = new ReminderSource({ storage: new InMemoryReminderStorage() })
-
-			expect(source.id).toBe("freya.reminders")
-			const actions = await source.listActions()
-
-			expect(actions[ReminderAction.CreateReminder]?.id).toBe(ReminderAction.CreateReminder)
-			expect(actions[ReminderAction.UpdateReminder]?.id).toBe(ReminderAction.UpdateReminder)
-			expect(actions[ReminderAction.DeleteReminder]?.id).toBe(ReminderAction.DeleteReminder)
-			expect(actions[ReminderAction.CompleteReminder]?.id).toBe(ReminderAction.CompleteReminder)
-			expect(actions[ReminderAction.UncompleteReminder]?.id).toBe(ReminderAction.UncompleteReminder)
-		})
-
-		test("fetchContext returns null", async () => {
-			const source = new ReminderSource({ storage: new InMemoryReminderStorage() })
-
-			await expect(source.fetchContext(context("2026-06-12T09:00:00Z"))).resolves.toBeNull()
-		})
-
-		test("notifies item listeners after source actions", async () => {
-			const storage = new InMemoryReminderStorage()
-			const source = new ReminderSource({ storage })
-			const listener = mock()
-			source.onItemsUpdate(listener)
-
-			await source.createReminder({
-				title: "Buy milk",
-				dueAt: new Date("2026-06-12T18:00:00Z"),
-			})
-
-			expect(listener).toHaveBeenCalled()
-		})
-	})
-
-	describe("fetchItems", () => {
-		test("returns a one-off reminder occurrence", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					id: "buy-milk",
-					title: "Buy milk",
-					dueAt: new Date("2026-06-12T18:00:00Z"),
-				}),
-			])
-			const source = new ReminderSource({ storage, lookBackMs: 0 })
-
-			const items = await source.fetchItems(context("2026-06-12T12:00:00Z"))
-
-			expect(items).toHaveLength(1)
-			expect(items[0]!.data.title).toBe("Buy milk")
-			expect(items[0]!.data.reminderId).toBe("buy-milk")
-			expect(items[0]!.signals?.timeRelevance).toBe(TimeRelevance.Upcoming)
-		})
-
-		test("expands daily recurrence inside the feed window", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-10T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Daily,
-						interval: 1,
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 48 * 60 * 60 * 1000,
-			})
-
-			const items = await source.fetchItems(context("2026-06-12T00:00:00Z"))
-
-			expect(
-				items.map(function dueAt(item) {
-					return item.data.dueAt.toISOString()
-				}),
-			).toEqual(["2026-06-12T09:00:00.000Z", "2026-06-13T09:00:00.000Z"])
-		})
-
-		test("expands weekly recurrence on selected weekdays", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-08T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Weekly,
-						interval: 1,
-						weekdays: [ReminderWeekday.Monday, ReminderWeekday.Wednesday, ReminderWeekday.Friday],
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 6 * 24 * 60 * 60 * 1000,
-			})
-
-			const items = await source.fetchItems(context("2026-06-08T00:00:00Z"))
-
-			expect(
-				items.map(function dueAt(item) {
-					return item.data.dueAt.toISOString()
-				}),
-			).toEqual([
-				"2026-06-08T09:00:00.000Z",
-				"2026-06-10T09:00:00.000Z",
-				"2026-06-12T09:00:00.000Z",
-			])
-		})
-
-		test("deduplicates weekly weekdays before applying recurrence count", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-08T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Weekly,
-						interval: 1,
-						weekdays: [ReminderWeekday.Monday, ReminderWeekday.Monday, ReminderWeekday.Wednesday],
-						count: 3,
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 14 * 24 * 60 * 60 * 1000,
-			})
-
-			const items = await source.fetchItems(context("2026-06-08T00:00:00Z"))
-
-			expect(
-				items.map(function dueAt(item) {
-					return item.data.dueAt.toISOString()
-				}),
-			).toEqual([
-				"2026-06-08T09:00:00.000Z",
-				"2026-06-10T09:00:00.000Z",
-				"2026-06-15T09:00:00.000Z",
-			])
-		})
-
-		test("omits completed occurrences by default", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-12T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Daily,
-						interval: 1,
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 48 * 60 * 60 * 1000,
-			})
-
-			await source.completeReminder({
-				reminderId: "r1",
-				occurrenceDueAt: new Date("2026-06-12T09:00:00Z"),
-				completedAt: new Date("2026-06-12T09:05:00Z"),
-			})
-
-			const items = await source.fetchItems(context("2026-06-12T00:00:00Z"))
-
-			expect(
-				items.map(function dueAt(item) {
-					return item.data.dueAt.toISOString()
-				}),
-			).toEqual(["2026-06-13T09:00:00.000Z"])
-		})
-	})
-
-	describe("updates", () => {
-		test("updates one recurring occurrence through an override", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-12T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Daily,
-						interval: 1,
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 48 * 60 * 60 * 1000,
-			})
-
-			const result = await source.updateReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.ThisOccurrence,
-				occurrenceDueAt: new Date("2026-06-12T09:00:00Z"),
-				patch: {
-					title: "Take vitamins with breakfast",
-					dueAt: new Date("2026-06-12T10:00:00Z"),
-				},
-			})
-
-			expect(result.type).toBe(ReminderUpdateResultType.UpdatedOccurrence)
-			expect(storage.reminders.get("r1")?.title).toBe("Take vitamins")
-
-			const items = await source.fetchItems(context("2026-06-12T00:00:00Z"))
-			expect(items[0]!.data.title).toBe("Take vitamins with breakfast")
-			expect(items[0]!.data.dueAt.toISOString()).toBe("2026-06-12T10:00:00.000Z")
-			expect(items[1]!.data.title).toBe("Take vitamins")
-		})
-
-		test("updates an entire recurring reminder", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-12T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Daily,
-						interval: 1,
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 48 * 60 * 60 * 1000,
-			})
-
-			await source.updateReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.EntireSeries,
-				patch: { title: "Take medication" },
-			})
-
-			const items = await source.fetchItems(context("2026-06-12T00:00:00Z"))
-			expect(
-				items.map(function title(item) {
-					return item.data.title
-				}),
-			).toEqual(["Take medication", "Take medication"])
-		})
-
-		test("splits a recurring reminder for this-and-future updates", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-10T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Daily,
-						interval: 1,
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 48 * 60 * 60 * 1000,
-			})
-
-			const result = await source.updateReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.ThisAndFuture,
-				occurrenceDueAt: new Date("2026-06-12T09:00:00Z"),
-				patch: {
-					title: "Take vitamins later",
-					dueAt: new Date("2026-06-12T10:00:00Z"),
-				},
-			})
-
-			expect(result.type).toBe(ReminderUpdateResultType.SplitReminder)
-			expect(storage.reminders.size).toBe(2)
-			expect(storage.reminders.get("r1")?.recurrence?.count).toBe(2)
-
-			const items = await source.fetchItems(context("2026-06-12T00:00:00Z"))
-			expect(
-				items.map(function itemLabel(item) {
-					return `${item.data.title}:${item.data.dueAt.toISOString()}`
-				}),
-			).toEqual([
-				"Take vitamins later:2026-06-12T10:00:00.000Z",
-				"Take vitamins later:2026-06-13T10:00:00.000Z",
-			])
-		})
-
-		test("updates weekly weekdays when a this-and-future split moves weekday", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-08T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Weekly,
-						interval: 1,
-						weekdays: [ReminderWeekday.Monday],
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 14 * 24 * 60 * 60 * 1000,
-			})
-
-			const result = await source.updateReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.ThisAndFuture,
-				occurrenceDueAt: new Date("2026-06-15T09:00:00Z"),
-				patch: {
-					dueAt: new Date("2026-06-16T09:00:00Z"),
-				},
-			})
-
-			expect(result.type).toBe(ReminderUpdateResultType.SplitReminder)
-			expect(
-				result.type === ReminderUpdateResultType.SplitReminder
-					? result.newReminder.recurrence?.weekdays
-					: null,
-			).toEqual([ReminderWeekday.Tuesday])
-
-			const items = await source.fetchItems(context("2026-06-15T00:00:00Z"))
-			expect(
-				items.map(function dueAt(item) {
-					return item.data.dueAt.toISOString()
-				}),
-			).toEqual(["2026-06-16T09:00:00.000Z", "2026-06-23T09:00:00.000Z"])
-		})
-
-		test("collapses single-occurrence updates on one-off reminders to the reminder", async () => {
-			const storage = new InMemoryReminderStorage([reminder()])
-			const source = new ReminderSource({ storage, lookBackMs: 0 })
-
-			await source.updateReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.ThisOccurrence,
-				occurrenceDueAt: new Date("2026-06-12T09:00:00Z"),
-				patch: { title: "Take supplements" },
-			})
-
-			expect(storage.reminders.get("r1")?.title).toBe("Take supplements")
-			expect(storage.overrides.size).toBe(0)
-		})
-
-		test("rejects one-off scoped updates with a mismatched occurrence", async () => {
-			const storage = new InMemoryReminderStorage([reminder()])
-			const source = new ReminderSource({ storage, lookBackMs: 0 })
-			const staleDueAt = new Date("2026-06-13T09:00:00Z")
-
-			for (const scope of [ReminderEditScope.ThisOccurrence, ReminderEditScope.ThisAndFuture]) {
-				await expect(
-					source.updateReminder({
-						reminderId: "r1",
-						scope,
-						occurrenceDueAt: staleDueAt,
-						patch: { title: "Should not apply" },
-					}),
-				).rejects.toThrow("occurrenceDueAt does not match this reminder")
-			}
-
-			expect(storage.reminders.get("r1")?.title).toBe("Take vitamins")
-			expect(storage.overrides.size).toBe(0)
-		})
-	})
-
-	describe("deletes", () => {
-		test("collapses single-occurrence deletes on one-off reminders to the reminder", async () => {
-			const storage = new InMemoryReminderStorage([reminder()])
-			const source = new ReminderSource({ storage, lookBackMs: 0 })
-
-			await source.deleteReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.ThisOccurrence,
-				occurrenceDueAt: new Date("2026-06-12T09:00:00Z"),
-			})
-
-			expect(storage.reminders.has("r1")).toBe(false)
-			expect(storage.overrides.size).toBe(0)
-		})
-
-		test("rejects one-off scoped deletes with a mismatched occurrence", async () => {
-			const storage = new InMemoryReminderStorage([reminder()])
-			const source = new ReminderSource({ storage, lookBackMs: 0 })
-			const staleDueAt = new Date("2026-06-13T09:00:00Z")
-
-			for (const scope of [ReminderEditScope.ThisOccurrence, ReminderEditScope.ThisAndFuture]) {
-				await expect(
-					source.deleteReminder({
-						reminderId: "r1",
-						scope,
-						occurrenceDueAt: staleDueAt,
-					}),
-				).rejects.toThrow("occurrenceDueAt does not match this reminder")
-			}
-
-			expect(storage.reminders.has("r1")).toBe(true)
-			expect(storage.overrides.size).toBe(0)
-		})
-
-		test("deletes one recurring occurrence through an override", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-12T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Daily,
-						interval: 1,
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 48 * 60 * 60 * 1000,
-			})
-
-			await source.deleteReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.ThisOccurrence,
-				occurrenceDueAt: new Date("2026-06-12T09:00:00Z"),
-			})
-
-			const items = await source.fetchItems(context("2026-06-12T00:00:00Z"))
-			expect(
-				items.map(function dueAt(item) {
-					return item.data.dueAt.toISOString()
-				}),
-			).toEqual(["2026-06-13T09:00:00.000Z"])
-		})
-
-		test("deduplicates weekly weekdays before ending this and future", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-08T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Weekly,
-						interval: 1,
-						weekdays: [ReminderWeekday.Monday, ReminderWeekday.Monday, ReminderWeekday.Wednesday],
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 14 * 24 * 60 * 60 * 1000,
-			})
-
-			await source.deleteReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.ThisAndFuture,
-				occurrenceDueAt: new Date("2026-06-10T09:00:00Z"),
-			})
-
-			expect(storage.reminders.get("r1")?.recurrence?.count).toBe(1)
-
-			const items = await source.fetchItems(context("2026-06-08T00:00:00Z"))
-			expect(
-				items.map(function dueAt(item) {
-					return item.data.dueAt.toISOString()
-				}),
-			).toEqual(["2026-06-08T09:00:00.000Z"])
-		})
-
-		test("ignores stale future overrides after deleting this and future", async () => {
-			const storage = new InMemoryReminderStorage([
-				reminder({
-					dueAt: new Date("2026-06-10T09:00:00Z"),
-					recurrence: {
-						frequency: ReminderRecurrenceFrequency.Daily,
-						interval: 1,
-					},
-				}),
-			])
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 48 * 60 * 60 * 1000,
-			})
-
-			await source.updateReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.ThisOccurrence,
-				occurrenceDueAt: new Date("2026-06-12T09:00:00Z"),
-				patch: {
-					title: "Take vitamins later",
-					dueAt: new Date("2026-06-12T10:00:00Z"),
-				},
-			})
-			expect(storage.overrides.size).toBe(1)
-
-			await source.deleteReminder({
-				reminderId: "r1",
-				scope: ReminderEditScope.ThisAndFuture,
-				occurrenceDueAt: new Date("2026-06-12T09:00:00Z"),
-			})
-
-			const items = await source.fetchItems(context("2026-06-12T00:00:00Z"))
-
-			expect(items).toEqual([])
-		})
-	})
-
-	describe("actions", () => {
-		test("executeAction creates reminders from ISO date input", async () => {
-			const storage = new InMemoryReminderStorage()
-			const source = new ReminderSource({
-				storage,
-				lookBackMs: 0,
-				lookAheadMs: 48 * 60 * 60 * 1000,
-			})
-
-			const created = await source.executeAction(ReminderAction.CreateReminder, {
-				title: "Review notes",
-				dueAt: "2026-06-12T15:00:00Z",
-				recurrence: {
-					frequency: "daily",
-					interval: 1,
-					count: 2,
-				},
-			})
-
-			expect((created as Reminder).id).toBe("reminder-1")
-			const items = await source.fetchItems(context("2026-06-12T12:00:00Z"))
-			expect(items).toHaveLength(2)
-		})
-
-		test("executeAction rejects unknown actions", async () => {
-			const source = new ReminderSource({ storage: new InMemoryReminderStorage() })
-
-			await expect(source.executeAction("missing", {})).rejects.toThrow("Unknown action")
-		})
-	})
-})

packages/freya-source-reminders/src/reminder-source.ts

@@ -1,633 +0,0 @@
-import type {
-	ActionDefinition,
-	Context,
-	ContextEntry,
-	FeedItemSignals,
-	FeedSource,
-} from "@freya/core"
-
-import { TimeRelevance, UnknownActionError } from "@freya/core"
-import { type } from "arktype"
-
-import type {
-	CompleteReminderInput,
-	CreateReminderInput,
-	DeleteReminderInput,
-	Reminder,
-	ReminderDeleteResult,
-	ReminderEditScope,
-	ReminderFeedItem,
-	ReminderOccurrence,
-	ReminderOccurrenceOverride,
-	ReminderOccurrenceOverrideInput,
-	ReminderOccurrencePatch,
-	ReminderPatch,
-	ReminderPriority,
-	ReminderStorage,
-	ReminderUpdateResult,
-	UncompleteReminderInput,
-	UpdateReminderInput,
-} from "./types.ts"
-
-import {
-	createReminderOccurrenceId,
-	expandReminderOccurrences,
-	findReminderOccurrenceIndex,
-	recurrenceAfterSplit,
-	stopRecurrenceAfterOccurrenceCount,
-} from "./recurrence.ts"
-import {
-	CompleteReminderInput as CompleteReminderInputSchema,
-	DeleteReminderInput as DeleteReminderInputSchema,
-	ReminderAction,
-	ReminderDeleteResultType,
-	ReminderEditScope as ReminderEditScopeValue,
-	ReminderFeedItemType,
-	ReminderPriority as ReminderPriorityValue,
-	ReminderRecurrenceFrequency,
-	ReminderTimeZoneInput,
-	ReminderUpdateResultType,
-	ReminderWeekday,
-	UncompleteReminderInput as UncompleteReminderInputSchema,
-	UpdateReminderInput as UpdateReminderInputSchema,
-	createReminderInputSchema,
-} from "./types.ts"
-
-interface ArkSchema<T> {
-	(value: unknown): T | InstanceType<typeof type.errors>
-}
-
-export interface ReminderSourceOptions {
-	storage: ReminderStorage
-	/** Default: 24 hours. */
-	lookAheadMs?: number
-	/** Default: 24 hours, so earlier reminders from today remain visible. */
-	lookBackMs?: number
-	/** Default: false. */
-	includeCompleted?: boolean
-	/** Default: UTC. Used when create input omits timeZone. */
-	defaultTimeZone?: string
-}
-
-const DEFAULT_LOOK_AHEAD_MS = 24 * 60 * 60 * 1000
-const DEFAULT_LOOK_BACK_MS = 24 * 60 * 60 * 1000
-const DEFAULT_TIME_ZONE = "UTC"
-
-const FIFTEEN_MINUTES_MS = 15 * 60 * 1000
-const ONE_HOUR_MS = 60 * 60 * 1000
-const ONE_DAY_MS = 24 * 60 * 60 * 1000
-
-/**
- * FeedSource for one-off and recurring reminders.
- *
- * ReminderSource stores only canonical reminders plus occurrence overrides.
- * It owns recurrence expansion, edit-scope semantics, and feed item signals.
- */
-export class ReminderSource implements FeedSource<ReminderFeedItem> {
-	readonly id = "freya.reminders"
-
-	private readonly storage: ReminderStorage
-	private readonly lookAheadMs: number
-	private readonly lookBackMs: number
-	private readonly includeCompleted: boolean
-	private readonly defaultTimeZone: string
-	private readonly createReminderInput: ReturnType<typeof createReminderInputSchema>
-	private readonly itemListeners = new Set<(items: ReminderFeedItem[]) => void>()
-
-	constructor(options: ReminderSourceOptions) {
-		this.storage = options.storage
-		this.lookAheadMs = options.lookAheadMs ?? DEFAULT_LOOK_AHEAD_MS
-		this.lookBackMs = options.lookBackMs ?? DEFAULT_LOOK_BACK_MS
-		this.includeCompleted = options.includeCompleted ?? false
-		this.defaultTimeZone = options.defaultTimeZone ?? DEFAULT_TIME_ZONE
-		assertSchema(ReminderTimeZoneInput, this.defaultTimeZone)
-		this.createReminderInput = createReminderInputSchema(this.defaultTimeZone)
-	}
-
-	async listActions(): Promise<Record<string, ActionDefinition>> {
-		return {
-			[ReminderAction.CreateReminder]: {
-				id: ReminderAction.CreateReminder,
-				description: "Create a reminder",
-			},
-			[ReminderAction.UpdateReminder]: {
-				id: ReminderAction.UpdateReminder,
-				description: "Update a reminder or scoped recurrence occurrence",
-			},
-			[ReminderAction.DeleteReminder]: {
-				id: ReminderAction.DeleteReminder,
-				description: "Delete a reminder or scoped recurrence occurrence",
-			},
-			[ReminderAction.CompleteReminder]: {
-				id: ReminderAction.CompleteReminder,
-				description: "Complete a reminder occurrence",
-			},
-			[ReminderAction.UncompleteReminder]: {
-				id: ReminderAction.UncompleteReminder,
-				description: "Clear completion for a reminder occurrence",
-			},
-		}
-	}
-
-	async executeAction(actionId: string, params: unknown): Promise<unknown> {
-		switch (actionId) {
-			case ReminderAction.CreateReminder:
-				return this.createReminder(assertSchema(this.createReminderInput, params))
-			case ReminderAction.UpdateReminder:
-				return this.updateReminder(assertSchema(UpdateReminderInputSchema, params))
-			case ReminderAction.DeleteReminder:
-				return this.deleteReminder(assertSchema(DeleteReminderInputSchema, params))
-			case ReminderAction.CompleteReminder:
-				return this.completeReminder(assertSchema(CompleteReminderInputSchema, params))
-			case ReminderAction.UncompleteReminder:
-				return this.uncompleteReminder(assertSchema(UncompleteReminderInputSchema, params))
-			default:
-				throw new UnknownActionError(actionId)
-		}
-	}
-
-	async fetchContext(_context: Context): Promise<readonly ContextEntry[] | null> {
-		return null
-	}
-
-	onItemsUpdate(callback: (items: ReminderFeedItem[]) => void): () => void {
-		this.itemListeners.add(callback)
-		const cleanupStorage = this.storage.subscribe?.(() => {
-			this.notifyItemsChanged()
-		})
-
-		return () => {
-			this.itemListeners.delete(callback)
-			cleanupStorage?.()
-		}
-	}
-
-	async fetchItems(context: Context): Promise<ReminderFeedItem[]> {
-		const from = new Date(context.time.getTime() - this.lookBackMs)
-		const to = new Date(context.time.getTime() + this.lookAheadMs)
-		const reminders = await this.storage.listReminders({
-			from,
-			to,
-			includeCompleted: this.includeCompleted,
-		})
-
-		if (reminders.length === 0) return []
-
-		const reminderIds = reminders.map(function reminderId(reminder) {
-			return reminder.id
-		})
-		const overrides = await this.storage.listOccurrenceOverrides({ reminderIds, from, to })
-		const overridesByReminderId = groupOverridesByReminderId(overrides)
-
-		const items: ReminderFeedItem[] = []
-		for (const reminder of reminders) {
-			const occurrences = expandReminderOccurrences(reminder, {
-				from,
-				to,
-				includeCompleted: this.includeCompleted,
-				overrides: overridesByReminderId.get(reminder.id),
-			})
-
-			for (const occurrence of occurrences) {
-				items.push(createFeedItem(occurrence, context.time, this.id))
-			}
-		}
-
-		return items.sort(compareFeedItems)
-	}
-
-	async createReminder(input: CreateReminderInput): Promise<Reminder> {
-		const reminder = await this.storage.createReminder(
-			assertSchema(this.createReminderInput, input),
-		)
-		this.notifyItemsChanged()
-		return reminder
-	}
-
-	async updateReminder(input: UpdateReminderInput): Promise<ReminderUpdateResult> {
-		const parsed = assertSchema(UpdateReminderInputSchema, input)
-		const reminder = await this.requireReminder(parsed.reminderId)
-		const result = await this.updateExistingReminder(reminder, parsed)
-		this.notifyItemsChanged()
-		return result
-	}
-
-	async deleteReminder(input: DeleteReminderInput): Promise<ReminderDeleteResult> {
-		const parsed = assertSchema(DeleteReminderInputSchema, input)
-		const reminder = await this.requireReminder(parsed.reminderId)
-		const result = await this.deleteExistingReminder(reminder, parsed)
-		this.notifyItemsChanged()
-		return result
-	}
-
-	async completeReminder(input: CompleteReminderInput): Promise<ReminderOccurrenceOverride> {
-		const parsed = assertSchema(CompleteReminderInputSchema, input)
-		const reminder = await this.requireReminder(parsed.reminderId)
-		const occurrenceDueAt = parsed.occurrenceDueAt
-		this.requireKnownOccurrence(reminder, occurrenceDueAt)
-
-		const override = await this.mergeOccurrenceOverride(reminder.id, occurrenceDueAt, {
-			completedAt: parsed.completedAt ?? new Date(),
-			deletedAt: null,
-		})
-
-		this.notifyItemsChanged()
-		return override
-	}
-
-	async uncompleteReminder(input: UncompleteReminderInput): Promise<ReminderOccurrenceOverride> {
-		const parsed = assertSchema(UncompleteReminderInputSchema, input)
-		const reminder = await this.requireReminder(parsed.reminderId)
-		const occurrenceDueAt = parsed.occurrenceDueAt
-		this.requireKnownOccurrence(reminder, occurrenceDueAt)
-
-		const override = await this.mergeOccurrenceOverride(reminder.id, occurrenceDueAt, {
-			completedAt: null,
-		})
-
-		this.notifyItemsChanged()
-		return override
-	}
-
-	private async updateExistingReminder(
-		reminder: Reminder,
-		input: UpdateReminderInput,
-	): Promise<ReminderUpdateResult> {
-		if (input.scope === ReminderEditScopeValue.EntireSeries) {
-			const updated = await this.storage.updateReminder(reminder.id, input.patch)
-			return {
-				type: ReminderUpdateResultType.UpdatedReminder,
-				reminder: updated,
-			}
-		}
-
-		const occurrenceDueAt = requireOccurrenceDueAt(input)
-		this.requireKnownOccurrence(reminder, occurrenceDueAt)
-
-		if (!reminder.recurrence) {
-			const updated = await this.storage.updateReminder(reminder.id, input.patch)
-			return {
-				type: ReminderUpdateResultType.UpdatedReminder,
-				reminder: updated,
-			}
-		}
-
-		if (input.scope === ReminderEditScopeValue.ThisOccurrence) {
-			if (hasOwn(input.patch, "recurrence")) {
-				throw new Error("recurrence cannot be changed for a single occurrence")
-			}
-
-			const { recurrence: _recurrence, ...occurrencePatch } = input.patch
-			const override = await this.mergeOccurrenceOverride(reminder.id, occurrenceDueAt, {
-				patch: occurrencePatch,
-			})
-			return {
-				type: ReminderUpdateResultType.UpdatedOccurrence,
-				override,
-			}
-		}
-
-		return this.splitReminder(reminder, occurrenceDueAt, input.patch)
-	}
-
-	private async deleteExistingReminder(
-		reminder: Reminder,
-		input: DeleteReminderInput,
-	): Promise<ReminderDeleteResult> {
-		if (input.scope === ReminderEditScopeValue.EntireSeries) {
-			await this.storage.deleteReminder(reminder.id)
-			return { type: ReminderDeleteResultType.DeletedReminder }
-		}
-
-		const occurrenceDueAt = requireOccurrenceDueAt(input)
-		this.requireKnownOccurrence(reminder, occurrenceDueAt)
-
-		if (!reminder.recurrence) {
-			await this.storage.deleteReminder(reminder.id)
-			return { type: ReminderDeleteResultType.DeletedReminder }
-		}
-
-		if (input.scope === ReminderEditScopeValue.ThisOccurrence) {
-			const override = await this.mergeOccurrenceOverride(reminder.id, occurrenceDueAt, {
-				deletedAt: new Date(),
-			})
-			return {
-				type: ReminderDeleteResultType.DeletedOccurrence,
-				override,
-			}
-		}
-
-		const occurrenceIndex = findReminderOccurrenceIndex(reminder, occurrenceDueAt)
-		if (occurrenceIndex === null) {
-			throw new Error("occurrenceDueAt does not match this reminder")
-		}
-		if (occurrenceIndex === 0) {
-			await this.storage.deleteReminder(reminder.id)
-			return { type: ReminderDeleteResultType.DeletedReminder }
-		}
-
-		const recurrence = stopRecurrenceAfterOccurrenceCount(reminder.recurrence, occurrenceIndex)
-		const updated = await this.storage.updateReminder(reminder.id, { recurrence })
-		return {
-			type: ReminderDeleteResultType.EndedReminder,
-			reminder: updated,
-		}
-	}
-
-	private async splitReminder(
-		reminder: Reminder,
-		occurrenceDueAt: Date,
-		patch: ReminderPatch,
-	): Promise<ReminderUpdateResult> {
-		if (!reminder.recurrence) {
-			const updated = await this.storage.updateReminder(reminder.id, patch)
-			return {
-				type: ReminderUpdateResultType.UpdatedReminder,
-				reminder: updated,
-			}
-		}
-
-		const occurrenceIndex = findReminderOccurrenceIndex(reminder, occurrenceDueAt)
-		if (occurrenceIndex === null) {
-			throw new Error("occurrenceDueAt does not match this reminder")
-		}
-
-		if (occurrenceIndex === 0) {
-			const updated = await this.storage.updateReminder(reminder.id, patch)
-			return {
-				type: ReminderUpdateResultType.UpdatedReminder,
-				reminder: updated,
-			}
-		}
-
-		const previousRecurrence = stopRecurrenceAfterOccurrenceCount(
-			reminder.recurrence,
-			occurrenceIndex,
-		)
-		const previousReminder = await this.storage.updateReminder(reminder.id, {
-			recurrence: previousRecurrence,
-		})
-		const newReminder = await this.storage.createReminder(
-			createSplitReminderInput(reminder, occurrenceDueAt, occurrenceIndex, patch),
-		)
-
-		return {
-			type: ReminderUpdateResultType.SplitReminder,
-			previousReminder,
-			newReminder,
-		}
-	}
-
-	private requireKnownOccurrence(reminder: Reminder, occurrenceDueAt: Date): void {
-		const occurrenceIndex = findReminderOccurrenceIndex(reminder, occurrenceDueAt)
-		if (occurrenceIndex === null) {
-			throw new Error("occurrenceDueAt does not match this reminder")
-		}
-	}
-
-	private async requireReminder(id: string): Promise<Reminder> {
-		const reminder = await this.storage.getReminder(id)
-		if (!reminder) {
-			throw new Error(`Reminder not found: ${id}`)
-		}
-		return reminder
-	}
-
-	private async mergeOccurrenceOverride(
-		reminderId: string,
-		originalDueAt: Date,
-		patch: Partial<ReminderOccurrenceOverrideInput>,
-	): Promise<ReminderOccurrenceOverride> {
-		const occurrenceId = createReminderOccurrenceId(originalDueAt)
-		const existing = await this.storage.getOccurrenceOverride(reminderId, occurrenceId)
-
-		const input: ReminderOccurrenceOverrideInput = {
-			reminderId,
-			occurrenceId,
-			originalDueAt,
-			patch: mergeOccurrencePatch(existing?.patch, patch.patch),
-			completedAt: hasOwn(patch, "completedAt")
-				? (patch.completedAt ?? null)
-				: existing?.completedAt,
-			deletedAt: hasOwn(patch, "deletedAt") ? (patch.deletedAt ?? null) : existing?.deletedAt,
-		}
-
-		return this.storage.upsertOccurrenceOverride(input)
-	}
-
-	private notifyItemsChanged(): void {
-		for (const listener of this.itemListeners) {
-			listener([])
-		}
-	}
-}
-
-function createFeedItem(
-	occurrence: ReminderOccurrence,
-	now: Date,
-	sourceId: string,
-): ReminderFeedItem {
-	return {
-		id: `reminder-${occurrence.reminderId}-${occurrence.occurrenceId}`,
-		sourceId,
-		type: ReminderFeedItemType.Reminder,
-		timestamp: now,
-		data: {
-			reminderId: occurrence.reminderId,
-			occurrenceId: occurrence.occurrenceId,
-			title: occurrence.title,
-			notes: occurrence.notes,
-			originalDueAt: occurrence.originalDueAt,
-			dueAt: occurrence.dueAt,
-			timeZone: occurrence.timeZone,
-			recurrence: occurrence.recurrence,
-			priority: occurrence.priority,
-			completedAt: occurrence.completedAt,
-		},
-		signals: computeSignals(occurrence, now),
-	}
-}
-
-function computeSignals(occurrence: ReminderOccurrence, now: Date): FeedItemSignals {
-	if (occurrence.completedAt) {
-		return { urgency: 0, timeRelevance: TimeRelevance.Ambient }
-	}
-
-	const msUntilDue = occurrence.dueAt.getTime() - now.getTime()
-	let urgency: number
-	let timeRelevance: TimeRelevance
-
-	if (msUntilDue < 0) {
-		urgency = 1
-		timeRelevance = TimeRelevance.Imminent
-	} else if (msUntilDue <= FIFTEEN_MINUTES_MS) {
-		urgency = 0.95
-		timeRelevance = TimeRelevance.Imminent
-	} else if (msUntilDue <= ONE_HOUR_MS) {
-		urgency = 0.8
-		timeRelevance = TimeRelevance.Imminent
-	} else if (msUntilDue <= ONE_DAY_MS) {
-		urgency = 0.5
-		timeRelevance = TimeRelevance.Upcoming
-	} else {
-		urgency = 0.2
-		timeRelevance = TimeRelevance.Ambient
-	}
-
-	return {
-		urgency: clamp01(urgency + priorityUrgencyAdjustment(occurrence.priority)),
-		timeRelevance,
-	}
-}
-
-function createSplitReminderInput(
-	reminder: Reminder,
-	occurrenceDueAt: Date,
-	occurrenceIndex: number,
-	patch: ReminderPatch,
-): CreateReminderInput {
-	const dueAt = patch.dueAt ?? occurrenceDueAt
-	const timeZone = patch.timeZone ?? reminder.timeZone
-	const recurrence = hasOwn(patch, "recurrence")
-		? (patch.recurrence ?? null)
-		: alignSplitRecurrence(
-				recurrenceAfterSplit(reminder.recurrence!, occurrenceIndex),
-				occurrenceDueAt,
-				reminder.timeZone,
-				dueAt,
-				timeZone,
-			)
-
-	return {
-		title: patch.title ?? reminder.title,
-		notes: hasOwn(patch, "notes") ? (patch.notes ?? null) : reminder.notes,
-		dueAt,
-		timeZone,
-		recurrence,
-		priority: patch.priority ?? reminder.priority,
-	}
-}
-
-function alignSplitRecurrence(
-	recurrence: Reminder["recurrence"],
-	occurrenceDueAt: Date,
-	occurrenceTimeZone: string,
-	dueAt: Date,
-	timeZone: string,
-): Reminder["recurrence"] {
-	if (
-		!recurrence ||
-		recurrence.frequency !== ReminderRecurrenceFrequency.Weekly ||
-		!recurrence.weekdays?.length
-	) {
-		return recurrence
-	}
-
-	const previousWeekday = weekdayForDate(occurrenceDueAt, occurrenceTimeZone)
-	const nextWeekday = weekdayForDate(dueAt, timeZone)
-	if (previousWeekday === nextWeekday || recurrence.weekdays.includes(nextWeekday)) {
-		return recurrence
-	}
-
-	const weekdays = recurrence.weekdays
-		.filter(function keepOtherWeekdays(weekday) {
-			return weekday !== previousWeekday
-		})
-		.concat(nextWeekday)
-		.sort(compareWeekdays)
-
-	return { ...recurrence, weekdays }
-}
-
-function weekdayForDate(date: Date, timeZone: string): ReminderWeekday {
-	const parts = new Intl.DateTimeFormat("en-US", {
-		timeZone,
-		year: "numeric",
-		month: "2-digit",
-		day: "2-digit",
-	}).formatToParts(date)
-
-	const year = numberDatePart(parts, "year")
-	const month = numberDatePart(parts, "month")
-	const day = numberDatePart(parts, "day")
-	return new Date(Date.UTC(year, month - 1, day)).getUTCDay() as ReminderWeekday
-}
-
-function numberDatePart(
-	parts: Intl.DateTimeFormatPart[],
-	type: Intl.DateTimeFormatPartTypes,
-): number {
-	const part = parts.find(function matchesType(value) {
-		return value.type === type
-	})
-	if (!part) {
-		throw new Error(`Missing ${type} part while formatting reminder date`)
-	}
-	return Number(part.value)
-}
-
-function compareWeekdays(a: ReminderWeekday, b: ReminderWeekday): number {
-	return a - b
-}
-
-function mergeOccurrencePatch(
-	existing: ReminderOccurrencePatch | undefined,
-	next: ReminderOccurrencePatch | undefined,
-): ReminderOccurrencePatch | undefined {
-	if (!existing) return next
-	if (!next) return existing
-	return { ...existing, ...next }
-}
-
-function groupOverridesByReminderId(
-	overrides: readonly ReminderOccurrenceOverride[],
-): Map<string, ReminderOccurrenceOverride[]> {
-	const grouped = new Map<string, ReminderOccurrenceOverride[]>()
-	for (const override of overrides) {
-		const list = grouped.get(override.reminderId) ?? []
-		list.push(override)
-		grouped.set(override.reminderId, list)
-	}
-	return grouped
-}
-
-function priorityUrgencyAdjustment(priority: ReminderPriority): number {
-	switch (priority) {
-		case ReminderPriorityValue.High:
-			return 0.1
-		case ReminderPriorityValue.Low:
-			return -0.1
-		case ReminderPriorityValue.Normal:
-			return 0
-	}
-}
-
-function requireOccurrenceDueAt(input: { scope: ReminderEditScope; occurrenceDueAt?: Date }): Date {
-	if (!input.occurrenceDueAt) {
-		throw new Error(`${input.scope} requires occurrenceDueAt`)
-	}
-	return input.occurrenceDueAt
-}
-
-function assertSchema<T>(schema: ArkSchema<T>, value: unknown): T {
-	const result = schema(value)
-	if (result instanceof type.errors) {
-		throw new Error(result.summary)
-	}
-	return result
-}
-
-function hasOwn<TObject extends object, TKey extends PropertyKey>(
-	object: TObject,
-	key: TKey,
-): object is TObject & Record<TKey, unknown> {
-	return Object.prototype.hasOwnProperty.call(object, key)
-}
-
-function clamp01(value: number): number {
-	return Math.max(0, Math.min(1, value))
-}
-
-function compareFeedItems(a: ReminderFeedItem, b: ReminderFeedItem): number {
-	return a.data.dueAt.getTime() - b.data.dueAt.getTime()
-}

packages/freya-source-reminders/src/renderer.tsx

@@ -1,62 +0,0 @@
-/** @jsxImportSource @nym.sh/jrx */
-
-import type { FeedItemRenderer } from "@freya/core"
-
-import { FeedCard, SansSerifText, SerifText } from "@freya/components"
-
-import type { ReminderOccurrenceData } from "./types.ts"
-
-import { ReminderPriority, ReminderRecurrenceFrequency } from "./types.ts"
-
-export const renderReminderFeedItem: FeedItemRenderer<"reminder", ReminderOccurrenceData> = (
-	item,
-) => {
-	const { data } = item
-	const status = data.completedAt ? "Completed" : formatDueStatus(data.dueAt)
-	const recurrence = formatRecurrence(data.recurrence)
-
-	return (
-		<FeedCard>
-			<SansSerifText content={status} style="text-xs uppercase" />
-			<SerifText content={data.title} style="text-lg" />
-			<SansSerifText content={formatDueAt(data.dueAt, data.timeZone)} style="text-sm" />
-			{data.notes ? <SansSerifText content={data.notes} style="text-sm text-secondary" /> : null}
-			{recurrence ? (
-				<SansSerifText content={recurrence} style="text-xs text-secondary uppercase" />
-			) : null}
-			{data.priority !== ReminderPriority.Normal ? (
-				<SansSerifText content={data.priority} style="text-xs text-secondary uppercase" />
-			) : null}
-		</FeedCard>
-	)
-}
-
-function formatDueAt(date: Date, timeZone: string): string {
-	return new Intl.DateTimeFormat("en-US", {
-		timeZone,
-		dateStyle: "medium",
-		timeStyle: "short",
-	}).format(date)
-}
-
-function formatDueStatus(date: Date): string {
-	const now = new Date()
-	if (date.getTime() < now.getTime()) return "Due"
-	return "Upcoming"
-}
-
-function formatRecurrence(recurrence: ReminderOccurrenceData["recurrence"]): string | null {
-	if (!recurrence) return null
-
-	const interval = recurrence.interval === 1 ? "" : `${recurrence.interval} `
-	switch (recurrence.frequency) {
-		case ReminderRecurrenceFrequency.Daily:
-			return recurrence.interval === 1 ? "Daily" : `Every ${interval}days`
-		case ReminderRecurrenceFrequency.Weekly:
-			return recurrence.interval === 1 ? "Weekly" : `Every ${interval}weeks`
-		case ReminderRecurrenceFrequency.Monthly:
-			return recurrence.interval === 1 ? "Monthly" : `Every ${interval}months`
-		case ReminderRecurrenceFrequency.Yearly:
-			return recurrence.interval === 1 ? "Yearly" : `Every ${interval}years`
-	}
-}

packages/freya-source-reminders/src/types.ts

@@ -1,373 +0,0 @@
-import type { FeedItem } from "@freya/core"
-
-import { type } from "arktype"
-
-export const ReminderPriority = {
-	Low: "low",
-	Normal: "normal",
-	High: "high",
-} as const
-
-export type ReminderPriority = (typeof ReminderPriority)[keyof typeof ReminderPriority]
-
-export const ReminderRecurrenceFrequency = {
-	Daily: "daily",
-	Weekly: "weekly",
-	Monthly: "monthly",
-	Yearly: "yearly",
-} as const
-
-export type ReminderRecurrenceFrequency =
-	(typeof ReminderRecurrenceFrequency)[keyof typeof ReminderRecurrenceFrequency]
-
-export const ReminderWeekday = {
-	Sunday: 0,
-	Monday: 1,
-	Tuesday: 2,
-	Wednesday: 3,
-	Thursday: 4,
-	Friday: 5,
-	Saturday: 6,
-} as const
-
-export type ReminderWeekday = (typeof ReminderWeekday)[keyof typeof ReminderWeekday]
-
-export const ReminderEditScope = {
-	ThisOccurrence: "this-occurrence",
-	ThisAndFuture: "this-and-future",
-	EntireSeries: "entire-series",
-} as const
-
-export type ReminderEditScope = (typeof ReminderEditScope)[keyof typeof ReminderEditScope]
-
-export const ReminderAction = {
-	CreateReminder: "create-reminder",
-	UpdateReminder: "update-reminder",
-	DeleteReminder: "delete-reminder",
-	CompleteReminder: "complete-reminder",
-	UncompleteReminder: "uncomplete-reminder",
-} as const
-
-export type ReminderAction = (typeof ReminderAction)[keyof typeof ReminderAction]
-
-export const ReminderUpdateResultType = {
-	UpdatedReminder: "updated-reminder",
-	UpdatedOccurrence: "updated-occurrence",
-	SplitReminder: "split-reminder",
-} as const
-
-export type ReminderUpdateResultType =
-	(typeof ReminderUpdateResultType)[keyof typeof ReminderUpdateResultType]
-
-export const ReminderDeleteResultType = {
-	DeletedReminder: "deleted-reminder",
-	DeletedOccurrence: "deleted-occurrence",
-	EndedReminder: "ended-reminder",
-} as const
-
-export type ReminderDeleteResultType =
-	(typeof ReminderDeleteResultType)[keyof typeof ReminderDeleteResultType]
-
-export const ReminderDateInput = type.or("Date", "string.date.iso.parse")
-export const ReminderTitleInput = type.pipe(
-	type.string,
-	function trimTitle(value) {
-		return value.trim()
-	},
-	type.string.atLeastLength(1),
-)
-export const ReminderTimeZoneInput = type("string", ":", function isTimeZone(value, ctx) {
-	try {
-		new Intl.DateTimeFormat("en-US", { timeZone: value }).format(new Date())
-		return true
-	} catch {
-		return ctx.reject("a valid IANA time zone")
-	}
-})
-
-export const ReminderPriorityInput = type.enumerated(
-	ReminderPriority.Low,
-	ReminderPriority.Normal,
-	ReminderPriority.High,
-)
-
-export const ReminderEditScopeInput = type.enumerated(
-	ReminderEditScope.ThisOccurrence,
-	ReminderEditScope.ThisAndFuture,
-	ReminderEditScope.EntireSeries,
-)
-
-export const ReminderRecurrenceFrequencyInput = type.enumerated(
-	ReminderRecurrenceFrequency.Daily,
-	ReminderRecurrenceFrequency.Weekly,
-	ReminderRecurrenceFrequency.Monthly,
-	ReminderRecurrenceFrequency.Yearly,
-)
-
-export const ReminderWeekdayInput = type.enumerated(0, 1, 2, 3, 4, 5, 6)
-
-export const ReminderRecurrenceInput = type({
-	"+": "reject",
-	frequency: ReminderRecurrenceFrequencyInput,
-	interval: ["number.integer >= 1", "=", 1],
-	"weekdays?": ReminderWeekdayInput.array().atLeastLength(1),
-	"count?": "number.integer >= 1",
-	"until?": ReminderDateInput,
-})
-
-const ReminderRecurrenceNullableInput = type.or(ReminderRecurrenceInput, "null")
-const ReminderNotesInput = type.or("string", "null")
-
-export const ReminderPatchInput = type({
-	"+": "reject",
-	"title?": ReminderTitleInput,
-	"notes?": ReminderNotesInput,
-	"dueAt?": ReminderDateInput,
-	"timeZone?": ReminderTimeZoneInput,
-	"recurrence?": ReminderRecurrenceNullableInput,
-	"priority?": ReminderPriorityInput,
-})
-
-export const ReminderOccurrencePatchInput = type({
-	"+": "reject",
-	"title?": ReminderTitleInput,
-	"notes?": ReminderNotesInput,
-	"dueAt?": ReminderDateInput,
-	"timeZone?": ReminderTimeZoneInput,
-	"priority?": ReminderPriorityInput,
-})
-
-export function createReminderInputSchema(defaultTimeZone: string) {
-	return type({
-		"+": "reject",
-		title: ReminderTitleInput,
-		notes: [ReminderNotesInput, "=", null],
-		dueAt: ReminderDateInput,
-		timeZone: [ReminderTimeZoneInput, "=", defaultTimeZone],
-		recurrence: [ReminderRecurrenceNullableInput, "=", null],
-		priority: [ReminderPriorityInput, "=", ReminderPriority.Normal],
-	})
-}
-
-export const UpdateReminderInput = type({
-	"+": "reject",
-	reminderId: ReminderTitleInput,
-	scope: ReminderEditScopeInput,
-	"occurrenceDueAt?": ReminderDateInput,
-	patch: ReminderPatchInput,
-})
-
-export const DeleteReminderInput = type({
-	"+": "reject",
-	reminderId: ReminderTitleInput,
-	scope: ReminderEditScopeInput,
-	"occurrenceDueAt?": ReminderDateInput,
-})
-
-export const CompleteReminderInput = type({
-	"+": "reject",
-	reminderId: ReminderTitleInput,
-	occurrenceDueAt: ReminderDateInput,
-	"completedAt?": ReminderDateInput,
-})
-
-export const UncompleteReminderInput = type({
-	"+": "reject",
-	reminderId: ReminderTitleInput,
-	occurrenceDueAt: ReminderDateInput,
-})
-
-export interface ReminderRecurrence {
-	frequency: ReminderRecurrenceFrequency
-	/** Repeat every N frequency units. Defaults to 1 when parsed from actions. */
-	interval: number
-	/** Weekly recurrences only. Defaults to the weekday of dueAt. */
-	weekdays?: ReminderWeekday[]
-	/** Maximum number of generated occurrences, including the first one. */
-	count?: number
-	/** Last allowed occurrence instant, inclusive. */
-	until?: Date
-}
-
-export interface Reminder {
-	id: string
-	title: string
-	notes: string | null
-	dueAt: Date
-	timeZone: string
-	recurrence: ReminderRecurrence | null
-	priority: ReminderPriority
-	createdAt: Date
-	updatedAt: Date
-}
-
-export interface CreateReminderInput {
-	title: string
-	notes?: string | null
-	dueAt: Date
-	timeZone?: string
-	recurrence?: ReminderRecurrence | null
-	priority?: ReminderPriority
-}
-
-export interface ReminderPatch {
-	title?: string
-	notes?: string | null
-	dueAt?: Date
-	timeZone?: string
-	recurrence?: ReminderRecurrence | null
-	priority?: ReminderPriority
-}
-
-export interface ReminderOccurrencePatch {
-	title?: string
-	notes?: string | null
-	dueAt?: Date
-	timeZone?: string
-	priority?: ReminderPriority
-}
-
-export interface ReminderOccurrenceOverrideInput {
-	reminderId: string
-	occurrenceId: string
-	originalDueAt: Date
-	patch?: ReminderOccurrencePatch
-	completedAt?: Date | null
-	deletedAt?: Date | null
-}
-
-export interface ReminderOccurrenceOverride extends ReminderOccurrenceOverrideInput {
-	createdAt?: Date
-	updatedAt?: Date
-}
-
-export interface ReminderOccurrence {
-	reminderId: string
-	occurrenceId: string
-	title: string
-	notes: string | null
-	originalDueAt: Date
-	dueAt: Date
-	timeZone: string
-	recurrence: ReminderRecurrence | null
-	priority: ReminderPriority
-	completedAt: Date | null
-}
-
-export interface ReminderListParams {
-	from: Date
-	to: Date
-	includeCompleted: boolean
-}
-
-export interface ReminderOccurrenceOverrideListParams {
-	reminderIds: readonly string[]
-	from: Date
-	to: Date
-}
-
-/**
- * Storage adapters should return reminders that may produce occurrences in the
- * requested window. For recurring reminders this can include records whose
- * first dueAt is before `from`. Returning a superset is valid; ReminderSource
- * performs final recurrence expansion, override application, and filtering.
- */
-export interface ReminderStorage {
-	listReminders(params: ReminderListParams): Promise<Reminder[]>
-	getReminder(id: string): Promise<Reminder | null>
-	createReminder(input: CreateReminderInput): Promise<Reminder>
-	updateReminder(id: string, patch: ReminderPatch): Promise<Reminder>
-	deleteReminder(id: string): Promise<void>
-	/**
-	 * Return overrides whose originalDueAt or patched dueAt may affect the
-	 * requested window. Returning a superset is valid.
-	 */
-	listOccurrenceOverrides(
-		params: ReminderOccurrenceOverrideListParams,
-	): Promise<ReminderOccurrenceOverride[]>
-	getOccurrenceOverride(
-		reminderId: string,
-		occurrenceId: string,
-	): Promise<ReminderOccurrenceOverride | null>
-	upsertOccurrenceOverride(
-		input: ReminderOccurrenceOverrideInput,
-	): Promise<ReminderOccurrenceOverride>
-	deleteOccurrenceOverride(reminderId: string, occurrenceId: string): Promise<void>
-	subscribe?(callback: () => void): () => void
-}
-
-export interface UpdateReminderInput {
-	reminderId: string
-	scope: ReminderEditScope
-	occurrenceDueAt?: Date
-	patch: ReminderPatch
-}
-
-export interface DeleteReminderInput {
-	reminderId: string
-	scope: ReminderEditScope
-	occurrenceDueAt?: Date
-}
-
-export interface CompleteReminderInput {
-	reminderId: string
-	occurrenceDueAt: Date
-	completedAt?: Date
-}
-
-export interface UncompleteReminderInput {
-	reminderId: string
-	occurrenceDueAt: Date
-}
-
-export type ReminderUpdateResult =
-	| {
-			type: typeof ReminderUpdateResultType.UpdatedReminder
-			reminder: Reminder
-	  }
-	| {
-			type: typeof ReminderUpdateResultType.UpdatedOccurrence
-			override: ReminderOccurrenceOverride
-	  }
-	| {
-			type: typeof ReminderUpdateResultType.SplitReminder
-			previousReminder: Reminder
-			newReminder: Reminder
-	  }
-
-export type ReminderDeleteResult =
-	| {
-			type: typeof ReminderDeleteResultType.DeletedReminder
-	  }
-	| {
-			type: typeof ReminderDeleteResultType.DeletedOccurrence
-			override: ReminderOccurrenceOverride
-	  }
-	| {
-			type: typeof ReminderDeleteResultType.EndedReminder
-			reminder: Reminder
-	  }
-
-export const ReminderFeedItemType = {
-	Reminder: "reminder",
-} as const
-
-export type ReminderFeedItemType = (typeof ReminderFeedItemType)[keyof typeof ReminderFeedItemType]
-
-export interface ReminderOccurrenceData extends Record<string, unknown> {
-	reminderId: string
-	occurrenceId: string
-	title: string
-	notes: string | null
-	originalDueAt: Date
-	dueAt: Date
-	timeZone: string
-	recurrence: ReminderRecurrence | null
-	priority: ReminderPriority
-	completedAt: Date | null
-}
-
-export type ReminderFeedItem = FeedItem<
-	typeof ReminderFeedItemType.Reminder,
-	ReminderOccurrenceData
->