@nbtca/prompt 1.4.1 → 1.5.0

package/dist/features/schedule-view.js

@@ -1,258 +1,84 @@
-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)
+import { createTimetableSchedule } from '@nbtca/nbtcal/timetable';
+import { addLocalDays, parseLocalMonday } from '../core/calendar-day.js';
+import { renderNextClassBanner, renderTodayTimeline } from './schedule-render.js';
+import { loadCurrentPointer, loadTimetableCache } from './schedule-store.js';
+import { sanitizeTimetable } from './timetable-sanitize.js';
+const WEEKDAYS = [1, 2, 3, 4, 5, 6, 7];
+function loadCachedTimetable() {
+    const pointer = loadCurrentPointer();
+    if (!pointer)
         return null;
-    const trimmed = value.trim();
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(trimmed))
+    const value = loadTimetableCache(pointer.termKey);
+    if (!value || typeof value !== 'object')
         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);
+    const candidate = value;
+    if (!Array.isArray(candidate.meetings) ||
+        !Array.isArray(candidate.periods) ||
+        !Array.isArray(candidate.unresolvedItems) ||
+        !Array.isArray(candidate.calendarDays) ||
+        !Array.isArray(candidate.warnings)) {
         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)
+    const fetchedAt = new Date(candidate.fetchedAt);
+    if (Number.isNaN(fetchedAt.getTime()))
         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));
-    }
+    return {
+        timetable: sanitizeTimetable({ ...candidate, fetchedAt }),
+        weekOneMonday: pointer.weekOneMonday,
+    };
 }
-/** 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)
+        const cached = loadCachedTimetable();
+        if (!cached)
             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);
+        const schedule = createTimetableSchedule(cached.timetable, {
+            weekOneMonday: cached.weekOneMonday,
+        });
+        return renderNextClassBanner(schedule.next(now), 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))
+        const cached = loadCachedTimetable();
+        if (!cached)
             return [];
-        const week = currentWeekNumber(ptr.weekOneMonday, now);
-        const today = meetingsOnDay(cached.meetings, campusWeekday(now), week);
-        return renderTodayTimeline(today, cached.periods, now).split('\n');
+        const schedule = createTimetableSchedule(cached.timetable, {
+            weekOneMonday: cached.weekOneMonday,
+        });
+        const week = schedule.weekAt(now);
+        const today = schedule.meetingsOnDay(week, schedule.weekdayAt(now));
+        return renderTodayTimeline(today, cached.timetable.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))
+        const cached = loadCachedTimetable();
+        if (!cached)
             return null;
-        const week = currentWeekNumber(ptr.weekOneMonday, now);
+        const schedule = createTimetableSchedule(cached.timetable, {
+            weekOneMonday: cached.weekOneMonday,
+        });
+        const week = schedule.weekAt(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);
+        const classDays = WEEKDAYS.map((weekday) => schedule.meetingsOnDay(week, weekday).length > 0);
+        const weekStartDate = addLocalDays(parseLocalMonday(cached.weekOneMonday), (week - 1) * 7);
         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;
+        return loadCachedTimetable()?.timetable.unresolvedItems.length ?? 0;
     }
     catch {
         return 0;

package/dist/features/status.js

@@ -1,53 +1,60 @@
 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 { padEndV, sanitizeTerminalLine, 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();
     return [
-        // NBTCA-owned services
         { name: trans.status.serviceHomepage, url: URLS.homepage, group: 'nbtca' },
         { name: trans.status.serviceDocs, url: URLS.docs, group: 'nbtca' },
         { name: trans.status.serviceIcal, url: URLS.calendar, group: 'nbtca' },
         { name: trans.status.serviceRepair, url: URLS.repair, group: 'nbtca' },
-        // External platforms
         { name: trans.status.serviceGithub, url: URLS.github, group: 'external' },
         { name: trans.status.serviceRoadmap, url: URLS.roadmap, group: 'external' },
-        // Intranet services (campus LAN only)
         { name: trans.status.serviceCloud, url: URLS.cloud, group: 'intranet', intranet: true },
         { name: trans.status.serviceMirror, url: URLS.mirror, group: 'intranet', intranet: true },
     ];
 }
 async function checkService(name, url, timeoutMs) {
     const start = Date.now();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    timeout.unref();
+    let response;
     try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        const response = await fetch(url, {
+        response = await fetch(url, {
             signal: controller.signal,
             redirect: 'follow',
             headers: { 'User-Agent': `NBTCA-CLI/${APP_INFO.version}` },
         });
-        clearTimeout(timeout);
         const latencyMs = Date.now() - start;
         const ok = response.status >= 200 && response.status < 400;
         return { name, url, ok, statusCode: response.status, latencyMs };
     }
     catch (err) {
         const latencyMs = Date.now() - start;
-        const error = err instanceof Error
-            ? (err.name === 'AbortError' ? 'Request timed out' : err.message)
-            : String(err);
+        const error = sanitizeTerminalLine(err instanceof Error
+            ? err.name === 'AbortError'
+                ? 'Request timed out'
+                : err.message
+            : String(err));
         return { name, url, ok: false, latencyMs, error };
     }
+    finally {
+        clearTimeout(timeout);
+        try {
+            await response?.body?.cancel();
+        }
+        catch {
+            // The response may already be closed by the runtime.
+        }
+    }
 }
-export async function checkServiceWithRetry(target, timeoutMs, retries) {
+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++) {
@@ -58,12 +65,16 @@ export async function checkServiceWithRetry(target, timeoutMs, retries) {
                 break;
         }
     }
-    return { ...lastResult, group: target.group, intranet: target.intranet };
+    return {
+        ...lastResult,
+        group: target.group,
+        ...(target.intranet === undefined ? {} : { intranet: target.intranet }),
+    };
 }
 export async function checkServices(options = {}) {
     const timeoutMs = options.timeoutMs ?? 6000;
     const retries = options.retries ?? 1;
-    return Promise.all(getServiceTargets().map(t => checkServiceWithRetry(t, timeoutMs, retries)));
+    return Promise.all(getServiceTargets().map((t) => checkServiceWithRetry(t, timeoutMs, retries)));
 }
 export function serializeServiceStatus(items) {
     return items.map((item) => ({
@@ -78,12 +89,12 @@ export function serializeServiceStatus(items) {
     }));
 }
 export function hasServiceFailures(items) {
-    return items.some(item => !item.ok && !item.intranet);
+    return items.some((item) => !item.ok && !item.intranet);
 }
 export function countServiceHealth(items) {
     let up = 0;
     let down = 0;
-    for (const item of items.filter(i => !i.intranet)) {
+    for (const item of items.filter((i) => !i.intranet)) {
         if (item.ok)
             up++;
         else
@@ -100,7 +111,7 @@ export function renderServiceStatusTable(items, options) {
     const applyCyan = useColor ? chalk.cyan : id;
     const applyLatency = useColor ? c.latency : (ms) => `${ms}ms`;
     const trans = t();
-    const nameWidth = Math.max(...items.map(i => visualWidth(i.name)), visualWidth(trans.status.service));
+    const nameWidth = Math.max(...items.map((i) => visualWidth(i.name)), visualWidth(trans.status.service));
     const statusWidth = 10;
     const onIcon = pickIcon('●', '+');
     const offIcon = pickIcon('✕', '!');
@@ -112,14 +123,22 @@ export function renderServiceStatusTable(items, options) {
         if (item.group !== currentGroup) {
             if (currentGroup !== undefined)
                 lines.push('');
-            const groupLabel = item.group === 'nbtca' ? trans.status.groupNbtca :
-                item.group === 'external' ? trans.status.groupExternal :
-                    item.group === 'intranet' ? trans.status.groupIntranet : '';
+            const groupLabel = item.group === 'nbtca'
+                ? trans.status.groupNbtca
+                : item.group === 'external'
+                    ? trans.status.groupExternal
+                    : item.group === 'intranet'
+                        ? trans.status.groupIntranet
+                        : '';
             lines.push(`  ${applyDim(groupLabel)}`);
             lines.push(`  ${applyDim(sep.repeat(nameWidth + statusWidth + 12))}`);
             currentGroup = item.group;
         }
-        const nameCol = padEndV(item.pending ? applyDim(item.name) : (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.pending) {
             statusLabel = applyDim(pickIcon('…', '.'));
@@ -141,37 +160,3 @@ export function renderServiceStatusTable(items, options) {
     }
     return lines.join('\n');
 }
-export async function showServiceStatus() {
-    const trans = t();
-    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();
-    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;
-}