cli-jaw 2.0.3 → 2.0.5

package/public/manager/src/dashboard-reminders/ReminderDetailPopover.tsx

@@ -0,0 +1,118 @@
+import { useEffect, useMemo, useState, type FormEvent } from 'react';
+import type { DashboardReminder, DashboardReminderPatchInput } from './reminders-api';
+
+type Props = {
+    item: DashboardReminder | null;
+    busy: boolean;
+    onClose: () => void;
+    onSave: (id: string, patch: DashboardReminderPatchInput) => void;
+};
+
+export function ReminderDetailPopover(props: Props) {
+    const [title, setTitle] = useState('');
+    const [notes, setNotes] = useState('');
+    const [dueAt, setDueAt] = useState('');
+    const [remindAt, setRemindAt] = useState('');
+
+    useEffect(() => {
+        setTitle(props.item?.title ?? '');
+        setNotes(props.item?.notes ?? '');
+        setDueAt(toLocalDateTime(props.item?.dueAt ?? null));
+        setRemindAt(toLocalDateTime(props.item?.remindAt ?? null));
+    }, [props.item]);
+
+    useEffect(() => {
+        if (!props.item) return;
+        const onKeyDown = (event: KeyboardEvent) => {
+            if (event.key === 'Escape') props.onClose();
+        };
+        document.addEventListener('keydown', onKeyDown);
+        return () => document.removeEventListener('keydown', onKeyDown);
+    }, [props]);
+
+    const changed = useMemo(() => {
+        if (!props.item) return false;
+        return (
+            title.trim() !== props.item.title ||
+            notes !== props.item.notes ||
+            dueAt !== toLocalDateTime(props.item.dueAt) ||
+            remindAt !== toLocalDateTime(props.item.remindAt)
+        );
+    }, [dueAt, notes, props.item, remindAt, title]);
+
+    if (!props.item) return null;
+
+    const item = props.item;
+
+    const onSubmit = (event: FormEvent) => {
+        event.preventDefault();
+        if (!item) return;
+        const nextTitle = title.trim();
+        if (!nextTitle) return;
+        const patch: DashboardReminderPatchInput = {};
+        if (nextTitle !== item.title) patch.title = nextTitle;
+        if (notes !== item.notes) patch.notes = notes;
+        if (dueAt !== toLocalDateTime(item.dueAt)) patch.dueAt = fromLocalDateTime(dueAt);
+        if (remindAt !== toLocalDateTime(item.remindAt)) patch.remindAt = fromLocalDateTime(remindAt);
+        if (Object.keys(patch).length === 0) {
+            props.onClose();
+            return;
+        }
+        props.onSave(item.id, patch);
+    };
+
+    return (
+        <div className="dashboard-reminder-popover-scrim" role="presentation" onMouseDown={props.onClose}>
+            <section
+                className="dashboard-reminder-popover"
+                role="dialog"
+                aria-modal="true"
+                aria-label="Reminder details"
+                onMouseDown={event => event.stopPropagation()}
+            >
+                <form onSubmit={onSubmit}>
+                    <header>
+                        <span>Reminder details</span>
+                        <button type="button" aria-label="Close reminder details" onClick={props.onClose}>×</button>
+                    </header>
+                    <label>
+                        <span>Title</span>
+                        <input value={title} onChange={event => setTitle(event.target.value)} aria-label="Reminder title" />
+                    </label>
+                    <label>
+                        <span>Notes</span>
+                        <textarea value={notes} onChange={event => setNotes(event.target.value)} aria-label="Reminder notes" rows={6} />
+                    </label>
+                    <div className="dashboard-reminder-popover-grid">
+                        <label>
+                            <span>Due</span>
+                            <input type="datetime-local" value={dueAt} onChange={event => setDueAt(event.target.value)} aria-label="Reminder due date" />
+                        </label>
+                        <label>
+                            <span>Remind</span>
+                            <input type="datetime-local" value={remindAt} onChange={event => setRemindAt(event.target.value)} aria-label="Reminder notification date" />
+                        </label>
+                    </div>
+                    <footer>
+                        <button type="button" onClick={props.onClose}>Cancel</button>
+                        <button type="submit" disabled={props.busy || !title.trim() || !changed}>Save</button>
+                    </footer>
+                </form>
+            </section>
+        </div>
+    );
+}
+
+function toLocalDateTime(value: string | null): string {
+    if (!value) return '';
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) return '';
+    const offset = date.getTimezoneOffset() * 60000;
+    return new Date(date.getTime() - offset).toISOString().slice(0, 16);
+}
+
+function fromLocalDateTime(value: string): string | null {
+    if (!value.trim()) return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}

package/public/manager/src/dashboard-reminders/reminder-order.ts

@@ -0,0 +1,45 @@
+import type { DashboardReminder } from './reminders-api';
+
+export const DEFAULT_RANK_STEP = 1000;
+
+export function compareManualPriority(left: DashboardReminder, right: DashboardReminder): number {
+    return (
+        focusedScore(left) - focusedScore(right)
+        || priorityScore(left) - priorityScore(right)
+        || manualRankScore(left) - manualRankScore(right)
+        || nextTimeScore(left) - nextTimeScore(right)
+        || Date.parse(left.sourceCreatedAt) - Date.parse(right.sourceCreatedAt)
+    );
+}
+
+export function nextRankBetween(previous: DashboardReminder | null, next: DashboardReminder | null): number {
+    const previousRank = previous?.manualRank ?? null;
+    const nextRank = next?.manualRank ?? null;
+    if (previousRank === null && nextRank === null) return DEFAULT_RANK_STEP;
+    if (previousRank === null && nextRank !== null) return nextRank - DEFAULT_RANK_STEP;
+    if (previousRank !== null && nextRank === null) return previousRank + DEFAULT_RANK_STEP;
+    if (previousRank !== null && nextRank !== null) return (previousRank + nextRank) / 2;
+    return DEFAULT_RANK_STEP;
+}
+
+function focusedScore(item: DashboardReminder): number {
+    return item.status === 'focused' ? 0 : 1;
+}
+
+function manualRankScore(item: DashboardReminder): number {
+    return item.manualRank ?? Number.MAX_SAFE_INTEGER;
+}
+
+function nextTimeScore(item: DashboardReminder): number {
+    const candidates = [item.remindAt, item.dueAt]
+        .filter((value): value is string => Boolean(value))
+        .map(value => Date.parse(value))
+        .filter((value): value is number => Number.isFinite(value));
+    return candidates.length > 0 ? Math.min(...candidates) : Number.MAX_SAFE_INTEGER;
+}
+
+function priorityScore(item: DashboardReminder): number {
+    if (item.priority === 'high') return 0;
+    if (item.priority === 'normal') return 1;
+    return 2;
+}

package/public/manager/src/dashboard-reminders/reminders-api.ts

@@ -0,0 +1,126 @@
+export type DashboardReminderStatus = 'open' | 'focused' | 'waiting' | 'done';
+export type DashboardReminderPriority = 'low' | 'normal' | 'high';
+export type DashboardReminderNotificationStatus =
+    | 'pending'
+    | 'delivered'
+    | 'no_channel'
+    | 'failed'
+    | 'invalid_remind_at';
+
+export type DashboardReminder = {
+    id: string;
+    title: string;
+    notes: string;
+    listId: string;
+    status: DashboardReminderStatus;
+    priority: DashboardReminderPriority;
+    manualRank: number | null;
+    dueAt: string | null;
+    remindAt: string | null;
+    linkedInstance: string | null;
+    subtasks: Array<{ id: string; title: string; done: boolean }>;
+    source: 'dashboard';
+    sourceCreatedAt: string;
+    sourceUpdatedAt: string;
+    mirroredAt: string;
+    notificationStatus: DashboardReminderNotificationStatus;
+    notificationAttemptedAt: string | null;
+    notificationError: string | null;
+    instanceId: string | null;
+    messageId: string | null;
+    turnIndex: number | null;
+    port: number | null;
+    threadKey: string | null;
+    sourceText: string | null;
+};
+
+export type DashboardRemindersResponse = {
+    ok: boolean;
+    items?: DashboardReminder[];
+};
+
+export type DashboardReminderCreateInput = {
+    title: string;
+    notes?: string | null;
+    listId?: string | null;
+    status?: DashboardReminderStatus;
+    priority?: DashboardReminderPriority;
+    manualRank?: number | null;
+    dueAt?: string | null;
+    remindAt?: string | null;
+    linkedInstance?: string | null;
+};
+
+export type DashboardReminderPatchInput = Partial<DashboardReminderCreateInput>;
+
+const BASE = '/api/dashboard/reminders';
+
+async function asJson<T>(res: Response): Promise<T> {
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`${res.status} ${body || res.statusText}`);
+    }
+    const contentType = res.headers.get('content-type') || '';
+    if (!contentType.includes('application/json')) {
+        throw new Error('Reminders API is not available in the running dashboard server. Rebuild and restart the dashboard backend to enable sync.');
+    }
+    return await res.json() as T;
+}
+
+function normalizeReminder(item: DashboardReminder): DashboardReminder {
+    return {
+        ...item,
+        notes: item.notes ?? '',
+        manualRank: typeof item.manualRank === 'number' && Number.isFinite(item.manualRank) ? item.manualRank : null,
+        dueAt: item.dueAt ?? null,
+        remindAt: item.remindAt ?? null,
+        linkedInstance: item.linkedInstance ?? null,
+        subtasks: Array.isArray(item.subtasks) ? item.subtasks : [],
+        notificationAttemptedAt: item.notificationAttemptedAt ?? null,
+        notificationError: item.notificationError ?? null,
+        instanceId: item.instanceId ?? null,
+        messageId: item.messageId ?? null,
+        turnIndex: item.turnIndex ?? null,
+        port: item.port ?? null,
+        threadKey: item.threadKey ?? null,
+        sourceText: item.sourceText ?? null,
+    };
+}
+
+function assertManualRankSupport(patch: DashboardReminderPatchInput, item: DashboardReminder): void {
+    if ('manualRank' in patch && !Object.hasOwn(item, 'manualRank')) {
+        throw new Error('Manual reminder ordering requires the dashboard backend to be rebuilt and restarted.');
+    }
+}
+
+export async function listReminders(): Promise<DashboardRemindersResponse> {
+    const res = await fetch(BASE, { credentials: 'same-origin', cache: 'no-store' });
+    const body = await asJson<DashboardRemindersResponse>(res);
+    return {
+        ...body,
+        items: Array.isArray(body.items) ? body.items.map(normalizeReminder) : [],
+    };
+}
+
+export async function createReminder(input: DashboardReminderCreateInput): Promise<DashboardReminder> {
+    const res = await fetch(BASE, {
+        method: 'POST',
+        credentials: 'same-origin',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(input),
+    });
+    const body = await asJson<{ item: DashboardReminder }>(res);
+    return normalizeReminder(body.item);
+}
+
+export async function updateReminder(id: string, patch: DashboardReminderPatchInput): Promise<DashboardReminder> {
+    const res = await fetch(`${BASE}/${encodeURIComponent(id)}`, {
+        method: 'PATCH',
+        credentials: 'same-origin',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(patch),
+    });
+    const body = await asJson<{ item: DashboardReminder }>(res);
+    assertManualRankSupport(patch, body.item);
+    return normalizeReminder(body.item);
+}

package/public/manager/src/dashboard-reminders/reminders-view-model.ts

@@ -0,0 +1,63 @@
+import type { DashboardReminder, DashboardReminderCreateInput, DashboardReminderPatchInput } from './reminders-api';
+import type { RemindersView } from './DashboardRemindersSidebar';
+import { compareManualPriority } from './reminder-order';
+
+export type MatrixBucket = 'urgentImportant' | 'important' | 'waiting' | 'later';
+
+export type MatrixSection = {
+    id: MatrixBucket;
+    title: string;
+    tone: 'red' | 'green' | 'amber' | 'blue';
+};
+
+export const MATRIX_SECTIONS: readonly MatrixSection[] = [
+    { id: 'urgentImportant', title: 'Important and Urgent', tone: 'red' },
+    { id: 'important', title: 'Important, Not Urgent', tone: 'green' },
+    { id: 'waiting', title: 'Waiting / Delegated', tone: 'amber' },
+    { id: 'later', title: 'Later', tone: 'blue' },
+] as const;
+
+export const MATRIX_DEFAULTS: Record<MatrixBucket, Pick<DashboardReminderCreateInput, 'listId' | 'status' | 'priority'>> = {
+    urgentImportant: { listId: 'today', status: 'open', priority: 'high' },
+    important: { listId: 'today', status: 'open', priority: 'normal' },
+    waiting: { listId: 'waiting', status: 'waiting', priority: 'normal' },
+    later: { listId: 'later', status: 'open', priority: 'low' },
+};
+
+export function matrixBucketToPatch(bucket: MatrixBucket): DashboardReminderPatchInput {
+    return MATRIX_DEFAULTS[bucket];
+}
+
+export function resolveReminderMatrixBucket(item: DashboardReminder): MatrixBucket | null {
+    if (item.status === 'done') return null;
+    if (item.status === 'focused') return 'urgentImportant';
+    if (item.status === 'waiting') return 'waiting';
+    if (item.listId === 'later' || item.priority === 'low') return 'later';
+    if (item.priority === 'high') return 'urgentImportant';
+    return 'important';
+}
+
+export function matrixItems(bucket: MatrixBucket, items: DashboardReminder[]): DashboardReminder[] {
+    return items.filter(item => resolveReminderMatrixBucket(item) === bucket).sort(compareManualPriority);
+}
+
+export function remindersForView(view: RemindersView, items: DashboardReminder[]): DashboardReminder[] {
+    if (view === 'matrix') return items.filter(item => item.status !== 'done').sort(compareManualPriority);
+    if (view === 'done') return items.filter(item => item.status === 'done').sort(compareManualPriority);
+    if (view === 'focused') return matrixItems('urgentImportant', items);
+    if (view === 'important') return matrixItems('important', items);
+    if (view === 'waiting') return matrixItems('waiting', items);
+    if (view === 'later') return matrixItems('later', items);
+    return items.filter(item => item.status !== 'done').sort(compareManualPriority);
+}
+
+export function countRemindersView(view: RemindersView, items: DashboardReminder[]): number {
+    return remindersForView(view, items).length;
+}
+
+export function rankTopPriorityItems(items: DashboardReminder[], limit = 3): DashboardReminder[] {
+    return items
+        .filter(item => item.status !== 'done')
+        .sort(compareManualPriority)
+        .slice(0, limit);
+}

package/public/manager/src/dashboard-reminders/useDashboardReminderDrag.ts

@@ -0,0 +1,55 @@
+import { useState, type DragEvent } from 'react';
+import type { DashboardReminder } from './reminders-api';
+import type { MatrixBucket } from './reminders-view-model';
+
+const REMINDER_MIME = 'application/x-jaw-dashboard-reminder';
+
+export type DashboardReminderDropTarget =
+    | { kind: 'bucket'; bucket: MatrixBucket; beforeId: string | null; afterId: string | null }
+    | { kind: 'priority'; beforeId: string | null; afterId: string | null };
+
+function hasReminderDragType(event: DragEvent): boolean {
+    return Array.from(event.dataTransfer.types).includes(REMINDER_MIME);
+}
+
+export function useDashboardReminderDrag(onDropReminder: (id: string, target: DashboardReminderDropTarget) => void) {
+    const [draggedId, setDraggedId] = useState<string | null>(null);
+    const [dropTarget, setDropTarget] = useState<DashboardReminderDropTarget | null>(null);
+
+    function start(item: DashboardReminder, event: DragEvent): void {
+        if (event.target instanceof HTMLElement && event.target.closest('input, textarea, button, [data-reminder-inline-edit="true"]')) {
+            event.preventDefault();
+            return;
+        }
+        event.dataTransfer.effectAllowed = 'move';
+        event.dataTransfer.setData(REMINDER_MIME, item.id);
+        setDraggedId(item.id);
+    }
+
+    function over(target: DashboardReminderDropTarget, event: DragEvent): void {
+        if (!hasReminderDragType(event)) return;
+        event.preventDefault();
+        event.dataTransfer.dropEffect = 'move';
+        setDropTarget(target);
+    }
+
+    function leave(): void {
+        setDropTarget(null);
+    }
+
+    function drop(target: DashboardReminderDropTarget, event: DragEvent): void {
+        if (!hasReminderDragType(event)) return;
+        event.preventDefault();
+        const id = event.dataTransfer.getData(REMINDER_MIME);
+        setDraggedId(null);
+        setDropTarget(null);
+        if (id) onDropReminder(id, target);
+    }
+
+    function end(): void {
+        setDraggedId(null);
+        setDropTarget(null);
+    }
+
+    return { draggedId, dropTarget, start, over, leave, drop, end };
+}

package/public/manager/src/dashboard-reminders/useRemindersFeed.ts

@@ -0,0 +1,72 @@
+import { useCallback, useEffect, useState } from 'react';
+import {
+    createReminder,
+    listReminders,
+    updateReminder,
+    type DashboardReminder,
+    type DashboardReminderCreateInput,
+    type DashboardReminderPatchInput,
+} from './reminders-api';
+
+export type RemindersFeedState = {
+    items: DashboardReminder[];
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+    create: (input: DashboardReminderCreateInput) => Promise<void>;
+    update: (id: string, patch: DashboardReminderPatchInput) => Promise<void>;
+};
+
+type UseRemindersFeedOptions = {
+    active: boolean;
+};
+
+export function useRemindersFeed(options: UseRemindersFeedOptions): RemindersFeedState {
+    const [items, setItems] = useState<DashboardReminder[]>([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    const load = useCallback(async (): Promise<void> => {
+        setLoading(true);
+        setError(null);
+        try {
+            const body = await listReminders();
+            setItems(body.items || []);
+        } catch (err) {
+            setError((err as Error).message);
+        } finally {
+            setLoading(false);
+        }
+    }, []);
+
+    const refresh = useCallback(async (): Promise<void> => {
+        await load();
+    }, [load]);
+
+    const create = useCallback(async (input: DashboardReminderCreateInput): Promise<void> => {
+        setError(null);
+        try {
+            const item = await createReminder(input);
+            setItems(current => [item, ...current.filter(existing => existing.id !== item.id)]);
+        } catch (err) {
+            setError((err as Error).message);
+        }
+    }, []);
+
+    const update = useCallback(async (id: string, patch: DashboardReminderPatchInput): Promise<void> => {
+        setError(null);
+        try {
+            const item = await updateReminder(id, patch);
+            setItems(current => current.map(existing => existing.id === id ? item : existing));
+        } catch (err) {
+            setError((err as Error).message);
+        }
+    }, []);
+
+    useEffect(() => {
+        if (!options.active) return;
+        void load();
+    }, [options.active, load]);
+
+    return { items, loading, error, refresh, create, update };
+}

package/public/manager/src/dashboard-schedule/DashboardScheduleWorkspace.tsx

@@ -9,6 +9,8 @@ import {
     type DashboardScheduledWork,
     type DispatchResult,
 } from './schedule-api';
+import { HelpTopicButton } from '../help/HelpTopicButton';
+import type { HelpTopicId } from '../help/helpContent';
 
 type HeartbeatJob = {
     id: string;
@@ -21,6 +23,7 @@ type Props = {
     active: boolean;
     activeGroup: ScheduleGroup;
     busyPorts?: ReadonlySet<number> | number[];
+    onOpenHelpTopic: (topic: HelpTopicId) => void;
 };
 
 async function fetchHeartbeatJobs(): Promise<HeartbeatJob[]> {
@@ -134,10 +137,13 @@ export function DashboardScheduleWorkspace(props: Props) {
     return (
         <section className="dashboard-schedule-workspace" aria-hidden={!props.active}>
             <header className="dashboard-schedule-workspace-header">
-                <h2>Automations</h2>
-                <p className="dashboard-schedule-workspace-subtitle">
-                    Manager-owned scheduled work. The dashboard ticks once a minute and dispatches due items.
-                </p>
+                <div>
+                    <h2>Automations</h2>
+                    <p className="dashboard-schedule-workspace-subtitle">
+                        Manager-owned scheduled work. The dashboard ticks once a minute and dispatches due items.
+                    </p>
+                </div>
+                <HelpTopicButton topic="schedule" label="Open Automations help" onOpen={props.onOpenHelpTopic} />
                 {jobs.length > 0 ? (
                     <p className="dashboard-schedule-legacy-notice" role="note">
                         ⚠️ {jobs.length} legacy heartbeat job(s) detected in this instance's <code>heartbeat.json</code>. They are