@nbtca/prompt 1.3.2 → 1.4.1

package/dist/features/schedule-view.js

@@ -0,0 +1,260 @@
+import path from 'node:path';
+import { createNbtTimetableClient, timetableToIcs, } from '@nbtca/nbtcal/timetable';
+import { runMenu, menuFooter } from '../core/components/menu.js';
+import { runTextInput } from '../core/components/text-input.js';
+import { enterScreen, breadcrumb } from '../core/transitions.js';
+import { createSpinner, success, error } from '../core/ui.js';
+import { c, type, space } from '../core/theme.js';
+import { t, fmt } from '../i18n/index.js';
+import { createSessionStore } from '../auth/session-store.js';
+import { withAuthenticatedSession, resolveTerm, relevantTerms, writePrivateIcs, isSessionExpired, safeMessage, JWXT_ORIGIN, } from './student-timetable.js';
+import { currentWeekNumber, campusWeekday, meetingsOnDay, nextMeeting } from './schedule-query.js';
+import { renderNextClassBanner, renderTodayClasses, renderTodayTimeline, renderWeekGrid } from './schedule-render.js';
+import { termKey, loadWeekOne, saveWeekOne, saveTimetableCache, saveCurrentPointer, loadCurrentPointer, loadTimetableCache, clearScheduleCache, } from './schedule-store.js';
+/** Loads a saved week-one Monday for `key`, or prompts for and persists a new one.
+ * Returns null when the user cancels or enters an unparsable date (caller aborts). */
+async function ensureWeekOne(key) {
+    const saved = loadWeekOne(key);
+    if (saved)
+        return saved;
+    const value = await runTextInput({
+        message: t().timetable.promptWeekOne,
+        placeholder: 'YYYY-MM-DD',
+    });
+    if (value === null)
+        return null;
+    const trimmed = value.trim();
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(trimmed))
+        return null;
+    if (Number.isNaN(new Date(`${trimmed}T00:00:00`).getTime()))
+        return null;
+    saveWeekOne(key, trimmed);
+    return trimmed;
+}
+/** Fetches a term's timetable behind a spinner, caching it on success. Returns null
+ * (after reporting the error) on failure so callers can keep the previous state. */
+async function fetchTimetableWithSpinner(client, term, key, weekOne) {
+    const trans = t();
+    const spinner = createSpinner(trans.calendar.loading);
+    try {
+        const tt = await client.fetchTerm(term);
+        spinner.stop();
+        saveTimetableCache(key, tt);
+        saveCurrentPointer(key, weekOne);
+        return tt;
+    }
+    catch (err) {
+        if (isSessionExpired(err)) {
+            spinner.stop();
+            throw err;
+        }
+        spinner.error(trans.timetable.genericError);
+        return null;
+    }
+}
+function renderHub(tt, weekOne, now) {
+    const week = currentWeekNumber(weekOne, now);
+    const today = meetingsOnDay(tt.meetings, campusWeekday(now), week);
+    const trans = t();
+    console.log();
+    const banner = renderNextClassBanner(nextMeeting(tt.meetings, tt.periods, weekOne, now), now);
+    console.log(banner || `${space.indent}${type.hint(trans.timetable.noNextClass)}`);
+    console.log();
+    console.log(renderTodayClasses(today, tt.periods, now));
+    console.log();
+    return { week, today };
+}
+async function switchTerm(client, catalog) {
+    const trans = t();
+    const picked = await runMenu({
+        title: trans.timetable.hubSwitchTerm,
+        options: relevantTerms(catalog).map((tm) => ({
+            value: `${tm.academicYear}:${tm.semester}`,
+            label: tm.academicYearLabel,
+            hint: tm.current ? trans.common.current : undefined,
+        })),
+        footer: menuFooter(),
+    });
+    if (picked === null)
+        return null;
+    const term = resolveTerm(catalog, picked);
+    const key = termKey(term);
+    const weekOne = await ensureWeekOne(key);
+    if (!weekOne)
+        return null;
+    const tt = await fetchTimetableWithSpinner(client, term, key, weekOne);
+    if (!tt)
+        return null;
+    return { term, key, weekOne, tt };
+}
+function exportTimetable(tt, term, key, weekOne) {
+    const trans = t();
+    const ics = timetableToIcs(tt, { weekOneMonday: weekOne, calendarName: `NBT ${term.academicYearLabel}` });
+    const out = `timetable-${key}.ics`;
+    try {
+        writePrivateIcs(out, ics);
+        success(fmt(trans.timetable.exported, { count: tt.meetings.length, file: path.resolve(out) }));
+    }
+    catch {
+        error(trans.timetable.genericError);
+    }
+}
+/** Interactive schedule hub: login/restore, resolve the current term, load or prompt
+ * for the week-one Monday, fetch the timetable, then loop a menu of today / week-grid /
+ * switch-term / export actions until the user cancels. */
+export async function showSchedule() {
+    const trans = t();
+    await enterScreen(breadcrumb(trans.timetable.menuEntry));
+    try {
+        await withAuthenticatedSession(async (session) => {
+            const client = createNbtTimetableClient(session.timetableTransport, { baseUrl: JWXT_ORIGIN });
+            const catalog = await client.listTerms();
+            let term = resolveTerm(catalog);
+            let key = termKey(term);
+            let weekOne = await ensureWeekOne(key);
+            if (!weekOne)
+                return 0;
+            const initial = await fetchTimetableWithSpinner(client, term, key, weekOne);
+            if (!initial)
+                return 1;
+            let tt = initial;
+            while (true) {
+                const now = new Date();
+                const { week, today } = renderHub(tt, weekOne, now);
+                const action = await runMenu({
+                    title: `${trans.timetable.menuEntry}  ${c.muted(term.academicYearLabel)}  ${c.muted(trans.timetable.weekLabel + String(week))}`,
+                    options: [
+                        { value: 'today', label: trans.timetable.hubToday, hint: String(today.length) },
+                        { value: 'week', label: trans.timetable.hubWeek },
+                        { value: 'term', label: trans.timetable.hubSwitchTerm, hint: term.academicYearLabel },
+                        { value: 'export', label: trans.timetable.hubExport },
+                        { value: 'logout', label: trans.timetable.hubLogout },
+                    ],
+                    footer: menuFooter(),
+                });
+                if (action === null)
+                    return 0;
+                if (action === 'today') {
+                    continue; // The next loop iteration repaints today's classes.
+                }
+                if (action === 'week') {
+                    console.log();
+                    console.log(renderWeekGrid(tt.meetings, tt.periods, week, now));
+                    console.log();
+                    continue;
+                }
+                if (action === 'term') {
+                    const switched = await switchTerm(client, catalog);
+                    if (!switched)
+                        continue;
+                    term = switched.term;
+                    key = switched.key;
+                    weekOne = switched.weekOne;
+                    tt = switched.tt;
+                    continue;
+                }
+                if (action === 'export') {
+                    exportTimetable(tt, term, key, weekOne);
+                    continue;
+                }
+                if (action === 'logout') {
+                    createSessionStore().clear();
+                    clearScheduleCache();
+                    return 0;
+                }
+            }
+        }, {
+            oneShot: false,
+            isInteractive: true,
+            store: createSessionStore(),
+            stderr: process.stderr,
+        });
+    }
+    catch (err) {
+        error(safeMessage(err));
+    }
+}
+/** Best-effort, cache-only startup line: reads the last-used term pointer and its
+ * cached timetable (no network) and renders the next-class banner, or '' if the
+ * student isn't "set up" yet or anything about the cache is missing/corrupt. */
+export function peekNextClassLine(now = new Date()) {
+    try {
+        const ptr = loadCurrentPointer();
+        if (!ptr)
+            return '';
+        const cached = loadTimetableCache(ptr.termKey);
+        if (!cached || !Array.isArray(cached.meetings) || !Array.isArray(cached.periods))
+            return '';
+        const next = nextMeeting(cached.meetings, cached.periods, ptr.weekOneMonday, now);
+        return renderNextClassBanner(next, now);
+    }
+    catch {
+        return '';
+    }
+}
+/** Cache-only (no network) render of today's classes for the current term, or
+ * [] if not set up. Uses the same renderTodayTimeline Schedule's own hub
+ * renders, so Home's preview and Schedule's detail view show the exact same
+ * visual language for the exact same data instead of drifting apart. */
+export function peekTodayLines(now = new Date()) {
+    try {
+        const ptr = loadCurrentPointer();
+        if (!ptr)
+            return [];
+        const cached = loadTimetableCache(ptr.termKey);
+        if (!cached || !Array.isArray(cached.meetings) || !Array.isArray(cached.periods))
+            return [];
+        const week = currentWeekNumber(ptr.weekOneMonday, now);
+        const today = meetingsOnDay(cached.meetings, campusWeekday(now), week);
+        return renderTodayTimeline(today, cached.periods, now).split('\n');
+    }
+    catch {
+        return [];
+    }
+}
+/** Best-effort, cache-only (no network) computation of this week's per-day
+ * class signal, for Home's combined week-overview grid. Returns null when
+ * there's no set-up personal timetable, the cache is unusable, or the term
+ * hasn't started yet (current week < 1) — the same "before term start"
+ * guard already fixed once for Schedule's own hub (a future-dated weekOne,
+ * auto-inferred while on break, must not render a nonsensical negative
+ * week's worth of content). */
+export function peekWeekAheadInfo(now = new Date()) {
+    try {
+        const ptr = loadCurrentPointer();
+        if (!ptr)
+            return null;
+        const cached = loadTimetableCache(ptr.termKey);
+        if (!cached || !Array.isArray(cached.meetings))
+            return null;
+        const week = currentWeekNumber(ptr.weekOneMonday, now);
+        if (week < 1)
+            return null;
+        const meetings = cached.meetings;
+        const classDays = [1, 2, 3, 4, 5, 6, 7].map((wd) => meetingsOnDay(meetings, wd, week).length > 0);
+        const base = new Date(`${ptr.weekOneMonday}T00:00:00`);
+        const weekStartDate = new Date(base.getTime() + (week - 1) * 7 * 86400000);
+        return { weekStartDate, classDays };
+    }
+    catch {
+        return null;
+    }
+}
+/** Best-effort, cache-only (no network) read of how many timetable items
+ * still need the student's attention — the same data buildHubField()
+ * (schedule.ts) already surfaces inside Schedule's own hub menu, exposed
+ * here so Home can show it too without a second source of truth. */
+export function peekUnresolvedCount() {
+    try {
+        const ptr = loadCurrentPointer();
+        if (!ptr)
+            return 0;
+        const cached = loadTimetableCache(ptr.termKey);
+        if (!cached || !Array.isArray(cached.unresolvedItems))
+            return 0;
+        return cached.unresolvedItems.length;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/features/settings.js

@@ -1,7 +1,6 @@
 /**
  * Unified settings — language, theme, about
  */
-import { select, isCancel, note } from '@clack/prompts';
 import chalk from 'chalk';
 import { applyColorModePreference, loadPreferences, resetPreferences, setColorMode, setIconMode, } from '../config/preferences.js';
 import { pickIcon } from '../core/icons.js';
@@ -10,6 +9,9 @@ import { padEndV } from '../core/text.js';
 import { success, warning } from '../core/ui.js';
 import { APP_INFO, URLS } from '../config/data.js';
 import { t, getCurrentLanguage, setLanguage, clearTranslationCache } from '../i18n/index.js';
+import { runMenu, menuFooter } from '../core/components/menu.js';
+import { note } from '../core/components/note.js';
+import { enterScreen, breadcrumb } from '../core/transitions.js';
 function notifyResult(saved, successMsg, warningMsg) {
     if (saved) {
         success(successMsg);
@@ -37,12 +39,14 @@ function showAbout() {
     note(content, trans.about.title);
 }
 export async function showSettingsMenu() {
+    await enterScreen(breadcrumb(t().menu.settings));
     while (true) {
         const trans = t();
         const prefs = loadPreferences();
         const currentLang = getCurrentLanguage();
-        const action = await select({
-            message: trans.theme.chooseAction,
+        const footer = menuFooter();
+        const action = await runMenu({
+            title: trans.theme.chooseAction,
             options: [
                 { value: 'language', label: trans.language.selectLanguage, hint: currentLang === 'zh' ? trans.language.zh : trans.language.en },
                 { value: 'icon', label: trans.theme.iconMode, hint: prefs.iconMode },
@@ -50,23 +54,26 @@ export async function showSettingsMenu() {
                 { value: 'reset', label: trans.theme.resetLabel },
                 { value: 'about', label: trans.about.title },
             ],
+            footer,
         });
-        if (isCancel(action))
+        if (action === null)
             return;
         if (action === 'about') {
             showAbout();
             continue;
         }
         if (action === 'language') {
-            const language = await select({
-                message: trans.language.selectLanguage,
-                options: [
-                    { value: 'zh', label: trans.language.zh, hint: currentLang === 'zh' ? trans.common.current : undefined },
-                    { value: 'en', label: trans.language.en, hint: currentLang === 'en' ? trans.common.current : undefined },
-                ],
-                initialValue: currentLang,
+            const langOptions = [
+                { value: 'zh', label: trans.language.zh, hint: currentLang === 'zh' ? trans.common.current : undefined },
+                { value: 'en', label: trans.language.en, hint: currentLang === 'en' ? trans.common.current : undefined },
+            ];
+            const language = await runMenu({
+                title: trans.language.selectLanguage,
+                options: langOptions,
+                footer,
+                initialIndex: Math.max(0, langOptions.findIndex(o => o.value === currentLang)),
             });
-            if (isCancel(language))
+            if (language === null)
                 continue;
             if (language !== currentLang) {
                 const saved = setLanguage(language);
@@ -76,16 +83,18 @@ export async function showSettingsMenu() {
             continue;
         }
         if (action === 'icon') {
-            const mode = await select({
-                message: trans.theme.chooseIconMode,
-                options: [
-                    { value: 'auto', label: trans.theme.modeAuto, hint: prefs.iconMode === 'auto' ? trans.common.current : undefined },
-                    { value: 'ascii', label: trans.theme.modeAscii, hint: prefs.iconMode === 'ascii' ? trans.common.current : undefined },
-                    { value: 'unicode', label: trans.theme.modeUnicode, hint: prefs.iconMode === 'unicode' ? trans.common.current : undefined },
-                ],
-                initialValue: prefs.iconMode,
+            const iconOptions = [
+                { value: 'auto', label: trans.theme.modeAuto, hint: prefs.iconMode === 'auto' ? trans.common.current : undefined },
+                { value: 'ascii', label: trans.theme.modeAscii, hint: prefs.iconMode === 'ascii' ? trans.common.current : undefined },
+                { value: 'unicode', label: trans.theme.modeUnicode, hint: prefs.iconMode === 'unicode' ? trans.common.current : undefined },
+            ];
+            const mode = await runMenu({
+                title: trans.theme.chooseIconMode,
+                options: iconOptions,
+                footer,
+                initialIndex: Math.max(0, iconOptions.findIndex(o => o.value === prefs.iconMode)),
             });
-            if (isCancel(mode))
+            if (mode === null)
                 continue;
             const saved = setIconMode(mode);
             resetIconCache();
@@ -93,16 +102,18 @@ export async function showSettingsMenu() {
             continue;
         }
         if (action === 'color') {
-            const mode = await select({
-                message: trans.theme.chooseColorMode,
-                options: [
-                    { value: 'auto', label: trans.theme.modeAuto, hint: prefs.colorMode === 'auto' ? trans.common.current : undefined },
-                    { value: 'on', label: trans.theme.modeOn, hint: prefs.colorMode === 'on' ? trans.common.current : undefined },
-                    { value: 'off', label: trans.theme.modeOff, hint: prefs.colorMode === 'off' ? trans.common.current : undefined },
-                ],
-                initialValue: prefs.colorMode,
+            const colorOptions = [
+                { value: 'auto', label: trans.theme.modeAuto, hint: prefs.colorMode === 'auto' ? trans.common.current : undefined },
+                { value: 'on', label: trans.theme.modeOn, hint: prefs.colorMode === 'on' ? trans.common.current : undefined },
+                { value: 'off', label: trans.theme.modeOff, hint: prefs.colorMode === 'off' ? trans.common.current : undefined },
+            ];
+            const mode = await runMenu({
+                title: trans.theme.chooseColorMode,
+                options: colorOptions,
+                footer,
+                initialIndex: Math.max(0, colorOptions.findIndex(o => o.value === prefs.colorMode)),
             });
-            if (isCancel(mode))
+            if (mode === null)
                 continue;
             const saved = setColorMode(mode);
             applyColorModePreference(false);

package/dist/features/status.js

@@ -1,9 +1,12 @@
 import chalk from 'chalk';
 import { APP_INFO, URLS } from '../config/data.js';
+import { getCapabilities } from '../core/capabilities.js';
+import { createPainter } from '../core/components/painter.js';
 import { pickIcon } from '../core/icons.js';
 import { padEndV, visualWidth } from '../core/text.js';
 import { c } from '../core/theme.js';
 import { createSpinner } from '../core/ui.js';
+import { enterScreen, breadcrumb } from '../core/transitions.js';
 import { t } from '../i18n/index.js';
 function getServiceTargets() {
     const trans = t();
@@ -44,7 +47,7 @@ async function checkService(name, url, timeoutMs) {
         return { name, url, ok: false, latencyMs, error };
     }
 }
-async function checkServiceWithRetry(target, timeoutMs, retries) {
+export async function checkServiceWithRetry(target, timeoutMs, retries) {
     let lastResult = await checkService(target.name, target.url, timeoutMs);
     if (!lastResult.ok) {
         for (let attempt = 0; attempt < retries; attempt++) {
@@ -116,9 +119,12 @@ export function renderServiceStatusTable(items, options) {
             lines.push(`  ${applyDim(sep.repeat(nameWidth + statusWidth + 12))}`);
             currentGroup = item.group;
         }
-        const nameCol = padEndV(item.intranet ? applyDim(item.name) : applyCyan(item.name), nameWidth);
+        const nameCol = padEndV(item.pending ? applyDim(item.name) : (item.intranet ? applyDim(item.name) : applyCyan(item.name)), nameWidth);
         let statusLabel;
-        if (item.ok) {
+        if (item.pending) {
+            statusLabel = applyDim(pickIcon('…', '.'));
+        }
+        else if (item.ok) {
             statusLabel = applyGreen(`${onIcon} ${trans.status.up}`);
         }
         else if (item.intranet) {
@@ -128,7 +134,7 @@ export function renderServiceStatusTable(items, options) {
             statusLabel = applyRed(`${offIcon} ${trans.status.down}`);
         }
         const statusCol = padEndV(statusLabel, statusWidth);
-        const latencyCol = item.ok && item.latencyMs != null
+        const latencyCol = !item.pending && item.ok && item.latencyMs != null
             ? applyLatency(item.latencyMs)
             : applyDim('—');
         lines.push(`  ${nameCol}  ${statusCol}  ${latencyCol}`);
@@ -137,17 +143,35 @@ export function renderServiceStatusTable(items, options) {
 }
 export async function showServiceStatus() {
     const trans = t();
-    const spinner = createSpinner(trans.status.checking);
-    const items = await checkServices();
-    const hasFailures = hasServiceFailures(items);
-    if (hasFailures) {
-        spinner.error(trans.status.summaryFail);
-    }
-    else {
-        spinner.stop(trans.status.summaryOk);
+    await enterScreen(breadcrumb(trans.menu.status));
+    const targets = getServiceTargets();
+    if (getCapabilities().reducedMotion) {
+        const spinner = createSpinner(trans.status.checking);
+        const items = await checkServices();
+        const hasFailures = hasServiceFailures(items);
+        if (hasFailures)
+            spinner.error(trans.status.summaryFail);
+        else
+            spinner.stop(trans.status.summaryOk);
+        console.log();
+        console.log(renderServiceStatusTable(items, { color: !!process.stdout.isTTY }));
+        console.log();
+        return items;
     }
+    const items = targets.map((tg) => ({
+        name: tg.name, url: tg.url, ok: false, group: tg.group, intranet: tg.intranet, pending: true,
+    }));
+    const paint = createPainter(() => renderServiceStatusTable(items, { color: getCapabilities().color }));
     console.log();
-    console.log(renderServiceStatusTable(items, { color: !!process.stdout.isTTY }));
+    paint();
+    await Promise.all(targets.map(async (target, i) => {
+        const status = await checkServiceWithRetry(target, 6000, 1);
+        items[i] = { ...status, pending: false };
+        paint();
+    }));
+    console.log('\n');
+    const hasFailures = hasServiceFailures(items);
+    console.log(hasFailures ? c.warn(trans.status.summaryFail) : c.success(trans.status.summaryOk));
     console.log();
     return items;
 }