@nbtca/prompt 1.1.3 → 1.3.0

package/dist/config/data.js

@@ -1,7 +1,4 @@
-/**
- * 核心URL配置
- * 集中管理所有外部链接
- */
+/** Core URL and application constants. */
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
@@ -25,6 +22,8 @@ export const URLS = {
     repair: 'https://nbtca.space/repair',
     calendar: 'https://ical.nbtca.space',
     email: 'contact@nbtca.space',
+    cloud: 'https://cloud.nbtca.space',
+    mirror: 'https://i.nbtca.space',
 };
 export const GITHUB_REPO = {
     owner: 'nbtca',
@@ -34,7 +33,7 @@ export const GITHUB_REPO = {
 export const APP_INFO = {
     name: 'Prompt',
     version: readPackageVersion(),
-    description: '浙大宁波理工学院计算机协会',
+    description: 'NingboTech Computer Association',
     author: 'm1ngsama <contact@m1ng.space>',
     license: 'MIT',
     repository: 'https://github.com/nbtca/prompt'

package/dist/core/menu.js

@@ -3,7 +3,7 @@
  */
 import { select, isCancel, outro } from '@clack/prompts';
 import chalk from 'chalk';
-import { showCalendar } from '../features/calendar.js';
+import { showCalendarMenu } from '../features/calendar.js';
 import { showDocsMenu } from '../features/docs.js';
 import { showServiceStatus } from '../features/status.js';
 import { showLinksMenu } from '../features/links.js';
@@ -36,7 +36,7 @@ export async function showMainMenu() {
 export async function runMenuAction(action) {
     switch (action) {
         case 'events':
-            await showCalendar();
+            await showCalendarMenu();
             break;
         case 'docs':
             await showDocsMenu();

package/dist/core/theme.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+export const c = {
+    brand: (s) => chalk.hex('#0ea5e9')(s),
+    accent: (s) => chalk.cyan(s),
+    success: (s) => chalk.green(s),
+    error: (s) => chalk.red(s),
+    warn: (s) => chalk.yellow(s),
+    heading: (s) => chalk.bold.white(s),
+    muted: (s) => chalk.dim(s),
+    subtle: (s) => chalk.gray(s),
+    label: (s) => chalk.bold.cyan(s),
+    url: (s) => chalk.dim.underline(s),
+    version: (s) => chalk.dim(s),
+    latency: (ms) => {
+        const s = `${ms}ms`;
+        if (ms < 200)
+            return chalk.green(s);
+        if (ms < 1000)
+            return chalk.yellow(s);
+        return chalk.red(s);
+    },
+};

package/dist/features/calendar.js

@@ -1,12 +1,8 @@
-/**
- * Calendar module
- * Fetches and renders upcoming events with Unicode box table.
- * Data layer powered by @nbtca/nbtcal.
- */
 import { loadCalendar, FeedFetchError, FeedParseError } from '@nbtca/nbtcal';
 import chalk from 'chalk';
 import { select, isCancel } from '@clack/prompts';
 import { info, createSpinner } from '../core/ui.js';
+import { c } from '../core/theme.js';
 import { pickIcon } from '../core/icons.js';
 import { padEndV, truncate } from '../core/text.js';
 import { t } from '../i18n/index.js';
@@ -26,9 +22,6 @@ function formatTime(date) {
     const minutes = String(date.getMinutes()).padStart(2, '0');
     return `${hours}:${minutes}`;
 }
-/**
- * Load the calendar, wrapping errors with a localized message.
- */
 async function loadCalendarOrThrow() {
     try {
         return await loadCalendar({ timeoutMs: 15000 });
@@ -40,9 +33,6 @@ async function loadCalendarOrThrow() {
         throw new Error(`${t().calendar.error}: ${detail}`);
     }
 }
-/**
- * Map a nbtcal CalendarEvent to prompt's Event type.
- */
 export function toDisplayEvent(e) {
     const trans = t();
     return {
@@ -54,15 +44,9 @@ export function toDisplayEvent(e) {
         startDate: e.start,
     };
 }
-/**
- * Fetch upcoming events (next 30 days), including recurring occurrences.
- */
 export async function fetchEvents() {
     return (await loadCalendarOrThrow()).upcoming({ days: 30 }).map(toDisplayEvent);
 }
-/**
- * Fetch trailing-year heatmap buckets.
- */
 export async function fetchHeatmapBuckets() {
     const now = new Date();
     const start = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000);
@@ -78,76 +62,139 @@ export function serializeEvents(events) {
         startDateISO: event.startDate.toISOString(),
     }));
 }
-/**
- * Render events as a Unicode box-drawing table
- */
 export function renderEventsTable(events, options) {
     const trans = t();
-    const color = options?.color !== false;
+    const useColor = options?.color !== false;
     if (events.length === 0)
-        return trans.calendar.noEvents;
-    const dateWidth = 16;
-    const titleWidth = 30;
-    const locationWidth = 16;
-    const h = pickIcon('─', '-');
-    const v = pickIcon('│', '|');
-    const topLeft = pickIcon('┌', '+');
-    const topMid = pickIcon('┬', '+');
-    const topRight = pickIcon('┐', '+');
-    const midLeft = pickIcon('├', '+');
-    const midMid = pickIcon('┼', '+');
-    const midRight = pickIcon('┤', '+');
-    const bottomLeft = pickIcon('└', '+');
-    const bottomMid = pickIcon('┴', '+');
-    const bottomRight = pickIcon('┘', '+');
-    const top = `${topLeft}${h.repeat(dateWidth + 2)}${topMid}${h.repeat(titleWidth + 2)}${topMid}${h.repeat(locationWidth + 2)}${topRight}`;
-    const divider = `${midLeft}${h.repeat(dateWidth + 2)}${midMid}${h.repeat(titleWidth + 2)}${midMid}${h.repeat(locationWidth + 2)}${midRight}`;
-    const bottom = `${bottomLeft}${h.repeat(dateWidth + 2)}${bottomMid}${h.repeat(titleWidth + 2)}${bottomMid}${h.repeat(locationWidth + 2)}${bottomRight}`;
-    const headerRow = `${v} ${padEndV(trans.calendar.dateTime, dateWidth)} ${v} ${padEndV(trans.calendar.eventName, titleWidth)} ${v} ${padEndV(trans.calendar.location, locationWidth)} ${v}`;
-    // Formatters are identity functions when color is off — one loop, no duplication
+        return `  ${trans.calendar.noEvents}`;
     const id = (s) => s;
-    const dim = color ? chalk.dim : id;
-    const bold = color ? chalk.bold : id;
-    const fmtDate = color ? chalk.cyan : id;
-    const fmtTitle = color ? chalk.white : id;
-    const fmtLoc = color ? chalk.gray : id;
-    const lines = [dim(top), bold(headerRow), dim(divider)];
+    const applyDim = useColor ? chalk.dim : id;
+    const applyCyan = useColor ? chalk.cyan : id;
+    const applyBold = useColor ? chalk.bold : id;
+    const applyGray = useColor ? chalk.gray : id;
+    // dateWidth must fit YYYY-MM-DD HH:MM (16 chars) for cross-year events
+    const dateWidth = 16;
+    const titleWidth = 32;
+    const locWidth = 14;
+    const sep = pickIcon('─', '-');
+    const headerDate = padEndV(applyDim(trans.calendar.dateTime), dateWidth);
+    const headerTitle = padEndV(applyDim(trans.calendar.eventName), titleWidth);
+    const headerLoc = applyDim(trans.calendar.location);
+    // divider covers exactly: dateWidth + 2-char sep + titleWidth + 2-char sep + locWidth
+    const divider = applyDim(sep.repeat(dateWidth + 2 + titleWidth + 2 + locWidth));
+    const lines = [
+        `  ${headerDate}  ${headerTitle}  ${headerLoc}`,
+        `  ${divider}`,
+    ];
     for (const event of events) {
-        const dateTime = `${event.date} ${event.time}`;
-        const title = truncate(event.title, titleWidth);
-        const location = truncate(event.location, locationWidth);
-        lines.push(`${v} ${fmtDate(padEndV(dateTime, dateWidth))} ${v} ${fmtTitle(padEndV(title, titleWidth))} ${v} ${fmtLoc(padEndV(location, locationWidth))} ${v}`);
+        const dateTime = event.time ? `${event.date} ${event.time}` : event.date;
+        const dateCol = padEndV(applyCyan(dateTime), dateWidth);
+        const titleCol = padEndV(applyBold(truncate(event.title, titleWidth)), titleWidth);
+        const locCol = applyGray(truncate(event.location, locWidth));
+        lines.push(`  ${dateCol}  ${titleCol}  ${locCol}`);
     }
-    lines.push(dim(bottom));
     return lines.join('\n');
 }
-function displayEvents(events) {
-    if (events.length === 0) {
-        info(t().calendar.noEvents);
-        return;
-    }
-    console.log();
-    console.log(renderEventsTable(events, { color: true }));
-    console.log(chalk.dim(`  ${pickIcon('📅', '[ical]')} ${t().calendar.subscribeHint}: ${URLS.calendar}`));
-    console.log();
+function renderSubscribeHint() {
+    const icon = pickIcon('◆', '*');
+    console.log(c.muted(`  ${icon} ${t().calendar.subscribeHint}: ${URLS.calendar}`));
 }
 async function showEventDetail(event) {
     const trans = t();
     console.log();
     console.log(chalk.bold.cyan(`  ${event.title}`));
-    console.log(chalk.dim(`  ${event.date} ${event.time}  ${pickIcon('·', '|')}  ${event.location}`));
+    console.log(c.muted(`  ${event.date}${event.time ? ' ' + event.time : ''}  ${pickIcon('·', '|')}  ${event.location}`));
     if (event.description) {
         console.log();
-        const lines = event.description.trim().split('\n');
-        for (const line of lines) {
-            console.log(chalk.white(`  ${line}`));
+        for (const line of event.description.trim().split('\n')) {
+            console.log(`  ${line}`);
         }
     }
     else {
-        console.log(chalk.dim(`  ${trans.calendar.noDescription}`));
+        console.log(c.muted(`  ${trans.calendar.noDescription}`));
     }
     console.log();
 }
+/** Startup preview: auto-loads and displays upcoming events, then returns. */
+export async function showEventsPreview() {
+    const trans = t();
+    const s = createSpinner(trans.calendar.loading);
+    try {
+        const cal = await loadCalendarOrThrow();
+        const events = cal.upcoming({ days: 30 }).map(toDisplayEvent);
+        if (events.length === 0) {
+            s.stop(trans.calendar.noEvents);
+        }
+        else {
+            s.stop(`${events.length} ${trans.calendar.eventsFound}`);
+        }
+        console.log();
+        console.log(renderEventsTable(events.slice(0, 5), { color: !!process.stdout.isTTY }));
+        console.log();
+        if (events.length > 0)
+            renderSubscribeHint();
+        console.log();
+    }
+    catch {
+        s.error(trans.calendar.error);
+        console.log();
+    }
+}
+/** Submenu: choose between upcoming and past events. */
+export async function showCalendarMenu() {
+    const trans = t();
+    const choice = await select({
+        message: trans.menu.chooseAction,
+        options: [
+            { value: 'upcoming', label: trans.menu.events, hint: trans.menu.eventsDesc },
+            { value: 'past', label: trans.calendar.pastEvents, hint: trans.calendar.pastEventsDesc },
+            { value: '__back__', label: c.muted(trans.common.back) },
+        ],
+    });
+    if (isCancel(choice) || choice === '__back__')
+        return;
+    if (choice === 'upcoming')
+        await showCalendar();
+    else if (choice === 'past')
+        await showPastEvents();
+}
+/** Past events: shows historical events from the last 30 days with detail selection. */
+export async function showPastEvents() {
+    const trans = t();
+    const s = createSpinner(trans.calendar.pastLoading);
+    try {
+        const cal = await loadCalendarOrThrow();
+        const events = cal.past({ days: 30 }).reverse().map(toDisplayEvent);
+        s.stop(`${events.length} ${trans.calendar.eventsFound}`);
+        console.log();
+        console.log(renderEventsTable(events, { color: true }));
+        console.log();
+        if (events.length === 0) {
+            info(trans.calendar.noPastEvents);
+            return;
+        }
+        const options = [
+            ...events.map((e, i) => ({
+                value: String(i),
+                label: `${e.date}${e.time ? ' ' + e.time : ''}  ${e.title}`,
+                hint: e.location,
+            })),
+            { value: '__back__', label: c.muted(trans.common.back) },
+        ];
+        const selected = await select({ message: trans.calendar.viewPastDetail, options });
+        if (!isCancel(selected) && selected !== '__back__') {
+            const event = events[Number.parseInt(selected, 10)];
+            if (event)
+                await showEventDetail(event);
+        }
+    }
+    catch {
+        s.error(trans.calendar.error);
+        console.log(c.muted('  ' + trans.calendar.errorHint));
+        console.log();
+    }
+}
+/** Full interactive calendar: heatmap + event list + detail selection. */
 export async function showCalendar() {
     const trans = t();
     const s = createSpinner(trans.calendar.loading);
@@ -155,7 +202,6 @@ export async function showCalendar() {
         const cal = await loadCalendarOrThrow();
         const events = cal.upcoming({ days: 30 }).map(toDisplayEvent);
         s.stop(`${events.length} ${trans.calendar.eventsFound}`);
-        // Render heatmap header
         const now = new Date();
         const heatmapBuckets = cal.heatmap({
             start: new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000),
@@ -164,31 +210,33 @@ export async function showCalendar() {
         });
         console.log();
         console.log(renderHeatmap(heatmapBuckets, now, { color: true }));
-        displayEvents(events);
-        if (events.length > 0) {
-            const options = [
-                ...events.map((e, i) => ({
-                    value: String(i),
-                    label: `${e.date} ${e.time}  ${e.title}`,
-                    hint: e.location,
-                })),
-                { value: '__back__', label: chalk.dim(trans.common.back) },
-            ];
-            const selected = await select({
-                message: trans.calendar.viewDetail,
-                options,
-            });
-            if (!isCancel(selected) && selected !== '__back__') {
-                const idx = Number.parseInt(selected, 10);
-                const event = events[idx];
-                if (event)
-                    await showEventDetail(event);
-            }
+        console.log();
+        console.log(renderEventsTable(events, { color: true }));
+        console.log();
+        renderSubscribeHint();
+        console.log();
+        if (events.length === 0) {
+            info(trans.calendar.noEvents);
+            return;
+        }
+        const options = [
+            ...events.map((e, i) => ({
+                value: String(i),
+                label: `${e.date}${e.time ? ' ' + e.time : ''}  ${e.title}`,
+                hint: e.location,
+            })),
+            { value: '__back__', label: c.muted(trans.common.back) },
+        ];
+        const selected = await select({ message: trans.calendar.viewDetail, options });
+        if (!isCancel(selected) && selected !== '__back__') {
+            const event = events[Number.parseInt(selected, 10)];
+            if (event)
+                await showEventDetail(event);
         }
     }
     catch {
         s.error(trans.calendar.error);
-        console.log(chalk.gray('  ' + trans.calendar.errorHint));
+        console.log(c.muted('  ' + trans.calendar.errorHint));
         console.log();
     }
 }

package/dist/features/docs.js

@@ -9,7 +9,7 @@ import { spawn, execFileSync } from 'child_process';
 import { URLS } from '../config/data.js';
 import { t, fmt } from '../i18n/index.js';
 import { setVimKeysActive } from '../core/vim-keys.js';
-import { createDocsClient, DocsFetchError } from '@nbtca/docs';
+import { createDocsClient } from '@nbtca/docs';
 function detectTerminalType() {
     const term = (process.env['TERM'] || '').toLowerCase();
     const termProgram = (process.env['TERM_PROGRAM'] || '').toLowerCase();
@@ -57,7 +57,6 @@ function ensureMarkedConfigured() {
 }
 // ─── marked-terminal renderer ─────────────────────────────────────────────────
 function getRendererOptions(type) {
-    // Cap at 80 columns — optimal prose reading width regardless of terminal size
     const width = Math.min(process.stdout.columns || 80, 80);
     const unicodeTableChars = {
         top: '─', 'top-mid': '┬', 'top-left': '┌', 'top-right': '┐',
@@ -75,23 +74,16 @@ function getRendererOptions(type) {
         width,
         emoji: true,
         unescape: true,
-        // Heading hierarchy: h1 cyan, h2+ white bold
         firstHeading: chalk.bold.cyan,
         heading: chalk.bold.white,
-        // Inline code: bright yellow, distinct from prose
         codespan: chalk.yellowBright,
-        // Block code: yellow (marked-terminal applies per-line)
         code: chalk.yellow,
-        // Blockquotes: italic gray, visually recessed
         blockquote: chalk.italic.gray,
-        // Prose emphasis
         strong: chalk.bold,
         em: chalk.italic,
         del: chalk.dim.strikethrough,
-        // Links: cyan underline
         link: chalk.cyan,
         href: chalk.cyan.underline,
-        // Tables with Unicode borders (fallback to ASCII on basic terminals)
         tableOptions: {
             chars: type === 'basic' ? asciiTableChars : unicodeTableChars
         }
@@ -101,17 +93,6 @@ const RENDER_CACHE_TTL_MS = 10 * 60 * 1000;
 const RENDER_CACHE_MAX = 50;
 const renderCache = new Map();
 let docsClient = createDocsClient();
-function getDocCategories() {
-    const trans = t();
-    return [
-        { name: trans.docs.categoryTutorial, path: 'tutorial' },
-        { name: trans.docs.categoryRepairLogs, path: '维修日' },
-        { name: trans.docs.categoryEvents, path: '相关活动举办' },
-        { name: trans.docs.categoryProcess, path: 'process' },
-        { name: trans.docs.categoryRepair, path: 'repair' },
-        { name: trans.docs.categoryArchived, path: 'archived' },
-    ];
-}
 function getFreshRender(key) {
     const entry = renderCache.get(key);
     return entry && entry.expiresAt > Date.now() ? entry.value : null;
@@ -131,18 +112,6 @@ export function clearDocsCache() {
     docsClient.clear();
     renderCache.clear();
 }
-async function fetchDirectory(path = '') {
-    try {
-        return await docsClient.listDir(path);
-    }
-    catch (err) {
-        const trans = t();
-        const msg = err instanceof DocsFetchError
-            ? (err.status === 403 ? `${trans.docs.githubForbidden}\n${trans.docs.githubTokenHint}` : `HTTP ${err.status}`)
-            : String(err);
-        throw new Error(fmt(trans.docs.fetchDirFailed, { error: msg }));
-    }
-}
 async function fetchFileContent(path) {
     try {
         return await docsClient.getFile(path);
@@ -167,14 +136,12 @@ function cleanMarkdownContent(content, type = getTerminalType()) {
     c = c.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, '');
     c = c.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, '');
     // 3. VitePress containers → blockquote with icon
-    //    ::: warning Title\ncontent\n:::
     c = c.replace(/^:::\s*(info|tip|warning|danger|details)\s*(.*?)\n([\s\S]*?)^:::\s*$/gm, (_m, type, title, body) => {
         const label = (title.trim() || type.charAt(0).toUpperCase() + type.slice(1));
         const icon = pickIcon(CONTAINER_ICONS_UNICODE[type] ?? '', CONTAINER_ICONS_ASCII[type] ?? '');
         const quoted = body.trimEnd().split('\n').map(l => `> ${l}`).join('\n');
         return `> ${icon} **${label}**\n>\n${quoted}\n`;
     });
-    // Remaining bare ::: markers
     c = c.replace(/^:::\s*\w*.*$/gm, '');
     // 4. GitHub / GitLab callout alerts  (> [!NOTE])
     c = c.replace(/^>\s*\[!(NOTE|TIP|WARNING|CAUTION|IMPORTANT)\]\s*$/gim, (_, type) => `> **${type.charAt(0) + type.slice(1).toLowerCase()}:**`);
@@ -200,32 +167,111 @@ function cleanMarkdownContent(content, type = getTerminalType()) {
     return c.trim();
 }
 function extractDocTitle(rawContent, cleanedContent) {
-    // 1. Try YAML frontmatter title: field (before it was stripped)
     const fmMatch = rawContent.match(/^---\n[\s\S]*?\n---/m);
     if (fmMatch) {
         const titleMatch = fmMatch[0].match(/^title:\s*['"]?(.+?)['"]?\s*$/m);
         if (titleMatch?.[1])
             return titleMatch[1].trim();
     }
-    // 2. Fallback to first # H1 heading in cleaned content
     const h1Match = cleanedContent.match(/^#\s+(.+)$/m);
     return h1Match?.[1]?.trim() ?? null;
 }
 /** Approximate reading time: ~200 words/min for technical Chinese/English prose. */
 function estimateReadTime(text) {
-    const cjkChars = (text.match(/[\u3400-\u9fff]/g) || []).length;
-    const nonCjk = text.replace(/[\u3400-\u9fff]/g, ' ');
+    const cjkChars = (text.match(/[㐀-鿿]/g) || []).length;
+    const nonCjk = text.replace(/[㐀-鿿]/g, ' ');
     const words = nonCjk.trim().split(/\s+/).filter(Boolean).length;
-    // Rough equivalence: 2 CJK chars ~= 1 "word" unit
     const units = words + cjkChars / 2;
     const mins = Math.max(1, Math.ceil(units / 220));
     return mins === 1 ? '~1 min' : `~${mins} min`;
 }
-// ─── Pager layer ──────────────────────────────────────────────────────────────
+/** Extract h2/h3 headings for TOC display (skips the h1 title). */
+function extractTOC(content) {
+    const lines = content.split('\n').filter(l => /^#{2,3}\s/.test(l));
+    return lines.map(l => {
+        const m = l.match(/^(#+)/);
+        const level = m?.[1]?.length ?? 2;
+        const text = l.replace(/^#+\s+/, '').trim();
+        return (level === 3 ? '  ' : '') + text;
+    });
+}
+/** True if the markdown source contains a table (pipe-delimited with separator row). */
+function hasMarkdownTable(content) {
+    return /^\|.+\|/m.test(content) && /^\|[-: |]+\|/m.test(content);
+}
+// ─── Document tree ────────────────────────────────────────────────────────────
+const TOP_SECTION_ORDER = ['tutorial', 'process', 'repair', 'archived'];
+const TOP_SECTION_SKIP = new Set(['docs', 'index.md', 'README.md']);
 /**
- * Display markdown via `glow` (Charmbracelet) if available — best-in-class
- * terminal markdown rendering with built-in pager and mouse support.
+ * Convert a kebab-case filename to a display-friendly title.
+ * Preserves Chinese characters and date prefixes.
  */
+function cleanFileName(name) {
+    const base = name.replace(/\.md$/, '');
+    if (/^[\d.]/.test(base))
+        return base;
+    return base
+        .replace(/[-_]/g, ' ')
+        .replace(/\b([a-z])/g, (_, c) => c.toUpperCase());
+}
+/** Group flat DocItem list into top-level sections. */
+function buildSections(all) {
+    const trans = t();
+    const labelMap = {
+        tutorial: trans.docs.categoryTutorial,
+        process: trans.docs.categoryProcess,
+        repair: trans.docs.categoryRepair,
+        archived: trans.docs.categoryArchived,
+    };
+    const groups = new Map();
+    for (const item of all) {
+        const parts = item.path.split('/');
+        if (parts.length < 2)
+            continue;
+        const top = parts[0];
+        if (TOP_SECTION_SKIP.has(top))
+            continue;
+        if (!TOP_SECTION_ORDER.includes(top))
+            continue;
+        if (!groups.has(top))
+            groups.set(top, []);
+        groups.get(top).push(item);
+    }
+    return TOP_SECTION_ORDER
+        .filter(k => groups.has(k))
+        .map(k => ({
+        key: k,
+        label: labelMap[k] ?? k,
+        count: groups.get(k).length,
+        files: groups.get(k),
+    }));
+}
+/** Group archived files by their second path component (year / manual / etc.). */
+function getArchivedGroups(files) {
+    const groups = new Map();
+    for (const item of files) {
+        const group = item.path.split('/')[1] ?? 'other';
+        if (!groups.has(group))
+            groups.set(group, []);
+        groups.get(group).push(item);
+    }
+    return groups;
+}
+async function loadSections() {
+    const trans = t();
+    const s = createSpinner(trans.docs.loading);
+    try {
+        const all = await docsClient.listAll();
+        const sections = buildSections(all);
+        s.stop();
+        return sections;
+    }
+    catch {
+        s.error(trans.docs.loadError);
+        return null;
+    }
+}
+// ─── Pager layer ──────────────────────────────────────────────────────────────
 async function displayWithGlow(cleanedMarkdown) {
     const cols = String(Math.min(process.stdout.columns || 80, 80));
     return new Promise(resolve => {
@@ -235,33 +281,34 @@ async function displayWithGlow(cleanedMarkdown) {
         child.stdin.write(cleanedMarkdown, 'utf-8');
         child.stdin.end();
         child.on('close', resolve);
-        child.on('error', resolve); // glow vanished mid-run — caller handles fallback
+        child.on('error', resolve);
     });
 }
-/**
- * Display rendered markdown via `less` with a structured document frame.
- * Flags:
- *   -R  pass raw ANSI codes through
- *   -F  exit immediately if content fits on one screen
- *   -X  don't clear the screen on exit
- *   -i  case-insensitive search (/ to search)
- *   -j4 place search hits 4 lines from the top (less jarring)
- */
-async function displayWithLess(rendered, title, filePath, readTime) {
+async function displayWithLess(rendered, title, filePath, readTime, toc) {
     const trans = t();
     const cols = Math.min(process.stdout.columns || 80, 80);
-    const rule = chalk.dim('-'.repeat(cols));
+    const rule = chalk.dim('─'.repeat(cols));
+    const tocBlock = toc.length >= 3
+        ? [
+            chalk.dim(`  ${trans.docs.tocTitle}`),
+            chalk.dim(`  ${'─'.repeat(36)}`),
+            ...toc.map(h => chalk.dim(`  ${h}`)),
+            chalk.dim(`  ${'─'.repeat(36)}`),
+            '',
+        ].join('\n')
+        : '';
     const header = [
         '',
         chalk.bold.cyan(`  ${title}`),
-        chalk.dim(`  ${filePath}`) + chalk.dim(`  |  ${readTime}`),
+        chalk.dim(`  ${filePath}`) + chalk.dim(`  ·  ${readTime}`),
         rule,
+        ...(tocBlock ? [tocBlock] : []),
         '',
     ].join('\n');
     const footer = [
         '',
         rule,
-        chalk.dim(`  ${trans.docs.endOfDocument}  |  / to search`),
+        chalk.dim(`  ${trans.docs.endOfDocument}  ·  / to search`),
         '',
     ].join('\n');
     const fullContent = header + rendered + footer;
@@ -286,66 +333,75 @@ async function displayWithLess(rendered, title, filePath, readTime) {
         }
     });
 }
-// ─── Directory browser ────────────────────────────────────────────────────────
-async function browseDirectory(initialPath = '') {
-    let currentPath = initialPath;
-    while (true) {
-        const trans = t();
-        let items;
-        try {
-            const s = createSpinner(currentPath ? `${trans.docs.loadingDir}: ${currentPath}` : trans.docs.loading);
-            items = await fetchDirectory(currentPath);
-            s.stop(currentPath || trans.docs.chooseDoc);
-        }
-        catch (err) {
-            error(trans.docs.loadError);
-            const errMsg = err instanceof Error ? err.message : String(err);
-            console.log(chalk.gray(`  ${trans.docs.errorHint}: ${errMsg}`));
-            setVimKeysActive(false);
-            const retry = await confirm({ message: trans.docs.retry });
-            setVimKeysActive(true);
-            if (!isCancel(retry) && retry)
-                continue;
-            return;
-        }
-        if (items.length === 0) {
-            warning(trans.docs.emptyDir);
-            if (currentPath) {
-                currentPath = currentPath.split('/').slice(0, -1).join('/');
-                continue;
-            }
-            return;
-        }
-        const options = [
-            ...(currentPath ? [{ value: '__back__', label: chalk.dim(trans.docs.upToParent) }] : []),
-            ...items.map(item => ({
-                value: item.path,
-                label: item.type === 'dir'
-                    ? chalk.cyan(`${item.name}/`)
-                    : item.name,
-                hint: item.type === 'dir' ? 'dir' : undefined,
-            })),
-            { value: '__exit__', label: chalk.dim(trans.docs.returnToMenu) },
-        ];
-        const selected = await select({
-            message: currentPath ? `${trans.docs.currentDir}: ${currentPath}` : trans.docs.chooseDoc,
-            options,
-        });
-        if (isCancel(selected) || selected === '__exit__')
-            return;
-        if (selected === '__back__') {
-            currentPath = currentPath.split('/').slice(0, -1).join('/');
-            continue;
-        }
-        const item = items.find(i => i.path === selected);
-        if (item?.type === 'dir') {
-            currentPath = selected;
-            continue;
-        }
-        if (item?.type === 'file') {
-            await viewMarkdownFile(selected);
-        }
+// ─── Section browsers ─────────────────────────────────────────────────────────
+/** Show a flat file list for tutorial / process / repair. */
+async function showDocSection(section) {
+    const trans = t();
+    if (section.key === 'archived') {
+        await showArchivedSection(section.files);
+        return;
     }
+    const files = section.files.filter(f => f.name !== 'index.md' && !f.name.startsWith('index.'));
+    if (files.length === 0)
+        return;
+    const selected = await select({
+        message: section.label,
+        options: [
+            ...files.map(f => {
+                const parts = f.path.split('/');
+                const hint = parts.length > 2 ? parts.slice(1, -1).join('/') : '';
+                return { value: f.path, label: cleanFileName(f.name), hint };
+            }),
+            { value: '__back__', label: chalk.dim(trans.common.back) },
+        ],
+    });
+    if (isCancel(selected) || selected === '__back__')
+        return;
+    await viewMarkdownFile(selected);
+}
+/** Show archived docs grouped by year, then files within the year. */
+async function showArchivedSection(files) {
+    const trans = t();
+    const groups = getArchivedGroups(files);
+    const sortedKeys = [...groups.keys()].sort((a, b) => {
+        const aYear = /^\d{4}$/.test(a);
+        const bYear = /^\d{4}$/.test(b);
+        if (aYear && bYear)
+            return Number(b) - Number(a);
+        if (aYear)
+            return -1;
+        if (bYear)
+            return 1;
+        return a.localeCompare(b);
+    });
+    const groupKey = await select({
+        message: trans.docs.categoryArchived,
+        options: [
+            ...sortedKeys.map(k => ({
+                value: k,
+                label: k,
+                hint: `${groups.get(k).length} docs`,
+            })),
+            { value: '__back__', label: chalk.dim(trans.common.back) },
+        ],
+    });
+    if (isCancel(groupKey) || groupKey === '__back__')
+        return;
+    const groupFiles = groups.get(groupKey) ?? [];
+    const fileSelected = await select({
+        message: `${trans.docs.categoryArchived} / ${groupKey}`,
+        options: [
+            ...groupFiles.map(f => ({
+                value: f.path,
+                label: cleanFileName(f.name),
+                hint: f.path.split('/').slice(2, -1).join('/'),
+            })),
+            { value: '__back__', label: chalk.dim(trans.common.back) },
+        ],
+    });
+    if (isCancel(fileSelected) || fileSelected === '__back__')
+        return;
+    await viewMarkdownFile(fileSelected);
 }
 // ─── Document viewer ──────────────────────────────────────────────────────────
 async function viewMarkdownFile(filePath) {
@@ -363,28 +419,31 @@ async function viewMarkdownFile(filePath) {
             }
             else {
                 const cleaned = cleanMarkdownContent(rawContent, getTerminalType());
-                const title = extractDocTitle(rawContent, cleaned) || filePath.split('/').pop() || filePath;
+                const title = extractDocTitle(rawContent, cleaned) || cleanFileName(filePath.split('/').pop() ?? filePath);
                 const readTime = estimateReadTime(cleaned);
                 const rendered = await marked(cleaned);
                 renderedDoc = { fingerprint, cleaned, rendered, title, readTime };
                 setRender(filePath, renderedDoc);
             }
             s.stop(`${chalk.bold(renderedDoc.title)}  ${chalk.dim(renderedDoc.readTime)}`);
+            const toc = extractTOC(renderedDoc.cleaned);
             if (hasGlow()) {
                 await displayWithGlow(renderedDoc.cleaned);
             }
             else {
-                await displayWithLess(renderedDoc.rendered, renderedDoc.title, filePath, renderedDoc.readTime);
+                await displayWithLess(renderedDoc.rendered, renderedDoc.title, filePath, renderedDoc.readTime, toc);
             }
             console.log();
             success(trans.docs.docCompleted);
             console.log();
+            const hasTable = hasMarkdownTable(rawContent);
             const action = await select({
                 message: trans.docs.chooseAction,
                 options: [
                     { value: 'back', label: trans.docs.backToList },
                     { value: 'reread', label: trans.docs.reread },
-                    { value: 'browser', label: trans.docs.openBrowser },
+                    { value: 'browser', label: trans.docs.openBrowser,
+                        hint: hasTable ? trans.docs.tableHint : undefined },
                 ],
             });
             if (isCancel(action) || action === 'back')
@@ -393,7 +452,7 @@ async function viewMarkdownFile(filePath) {
                 await openDocsInBrowser(filePath);
                 return;
             }
-            // action === 'reread' → continue loop
+            // 'reread' → loop
         }
         catch (err) {
             error(trans.docs.loadError);
@@ -439,63 +498,53 @@ async function searchDocs() {
         return;
     const keyword = query.trim().toLowerCase();
     const s = createSpinner(trans.docs.searching);
-    // Fetch all category directories in parallel
-    const categories = getDocCategories().filter(c => c.path !== 'README.md');
-    const results = [];
     try {
-        const fetches = await Promise.allSettled(categories.map(async (cat) => {
-            const items = await fetchDirectory(cat.path);
-            return { items, category: cat.name };
-        }));
-        for (const result of fetches) {
-            if (result.status !== 'fulfilled')
-                continue;
-            for (const item of result.value.items) {
-                if (item.name.toLowerCase().includes(keyword)) {
-                    results.push({ name: item.name, path: item.path, category: result.value.category });
-                }
-            }
-        }
+        const all = await docsClient.listAll();
+        const results = all.filter(item => item.path.toLowerCase().includes(keyword));
         s.stop(`${results.length} ${trans.docs.searchResults}`);
+        if (results.length === 0) {
+            warning(trans.docs.searchNoResults);
+            return;
+        }
+        const selected = await select({
+            message: trans.docs.chooseDoc,
+            options: [
+                ...results.map(r => ({
+                    value: r.path,
+                    label: cleanFileName(r.name),
+                    hint: r.path.includes('/') ? r.path.split('/').slice(0, -1).join('/') : '',
+                })),
+                { value: '__back__', label: chalk.dim(trans.docs.returnToMenu) },
+            ],
+        });
+        if (isCancel(selected) || selected === '__back__')
+            return;
+        await viewMarkdownFile(selected);
     }
     catch {
         s.error(trans.docs.loadError);
-        return;
-    }
-    if (results.length === 0) {
-        warning(trans.docs.searchNoResults);
-        return;
     }
-    const selected = await select({
-        message: trans.docs.chooseDoc,
-        options: [
-            ...results.map(r => ({
-                value: r.path,
-                label: r.name,
-                hint: r.category,
-            })),
-            { value: '__back__', label: chalk.dim(trans.docs.returnToMenu) },
-        ],
-    });
-    if (isCancel(selected) || selected === '__back__')
-        return;
-    await viewMarkdownFile(selected);
 }
 // ─── Menu ─────────────────────────────────────────────────────────────────────
 export async function showDocsMenu() {
+    let sections = await loadSections();
+    if (!sections)
+        return;
     while (true) {
         const trans = t();
-        const categories = getDocCategories();
-        const options = [
-            ...categories.map(cat => ({ value: cat.path, label: cat.name })),
-            { value: 'search', label: chalk.dim(trans.docs.searchPrompt.replace(':', '')) },
-            { value: 'refresh-cache', label: chalk.dim(trans.docs.refreshCache) },
-            { value: 'browser', label: chalk.dim(trans.docs.openBrowser) },
-            { value: 'back', label: chalk.dim(trans.docs.returnToMenu) },
-        ];
         const action = await select({
             message: trans.docs.chooseCategory,
-            options,
+            options: [
+                ...sections.map(sec => ({
+                    value: sec.key,
+                    label: sec.label,
+                    hint: `${sec.count} docs`,
+                })),
+                { value: 'search', label: chalk.dim(trans.docs.searchPrompt.replace(':', '')) },
+                { value: 'refresh-cache', label: chalk.dim(trans.docs.refreshCache) },
+                { value: 'browser', label: chalk.dim(trans.docs.openBrowser) },
+                { value: 'back', label: chalk.dim(trans.docs.returnToMenu) },
+            ],
         });
         if (isCancel(action) || action === 'back')
             return;
@@ -504,13 +553,16 @@ export async function showDocsMenu() {
         }
         else if (action === 'refresh-cache') {
             clearDocsCache();
+            sections = (await loadSections()) ?? sections;
             success(trans.docs.cacheCleared);
         }
         else if (action === 'browser') {
             await openDocsInBrowser();
         }
         else {
-            await browseDirectory(action);
+            const section = sections.find(s => s.key === action);
+            if (section)
+                await showDocSection(section);
         }
     }
 }

package/dist/features/status.js

@@ -1,17 +1,24 @@
 import chalk from 'chalk';
 import { APP_INFO, URLS } from '../config/data.js';
 import { pickIcon } from '../core/icons.js';
-import { padEndV } from '../core/text.js';
+import { padEndV, visualWidth } from '../core/text.js';
+import { c } from '../core/theme.js';
 import { createSpinner } from '../core/ui.js';
 import { t } from '../i18n/index.js';
 function getServiceTargets() {
     const trans = t();
     return [
-        { name: trans.status.serviceWebsite, url: URLS.homepage },
-        { name: trans.status.serviceDocs, url: URLS.docs },
-        { name: trans.status.serviceCalendar, url: URLS.calendar },
-        { name: trans.status.serviceGithub, url: URLS.github },
-        { name: trans.status.serviceRoadmap, url: URLS.roadmap },
+        // 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) {
@@ -37,25 +44,23 @@ async function checkService(name, url, timeoutMs) {
         return { name, url, ok: false, latencyMs, error };
     }
 }
-async function checkServiceWithRetry(name, url, timeoutMs, retries) {
-    let lastResult = await checkService(name, url, timeoutMs);
-    if (lastResult.ok)
-        return lastResult;
-    for (let attempt = 0; attempt < retries; attempt++) {
-        // Retry for transient transport errors and upstream server errors.
-        if (!lastResult.error && !(lastResult.statusCode != null && lastResult.statusCode >= 500)) {
-            break;
+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++) {
+            if (!lastResult.error && !(lastResult.statusCode != null && lastResult.statusCode >= 500))
+                break;
+            lastResult = await checkService(target.name, target.url, timeoutMs);
+            if (lastResult.ok)
+                break;
         }
-        lastResult = await checkService(name, url, timeoutMs);
-        if (lastResult.ok)
-            return lastResult;
     }
-    return lastResult;
+    return { ...lastResult, group: target.group, intranet: target.intranet };
 }
 export async function checkServices(options = {}) {
     const timeoutMs = options.timeoutMs ?? 6000;
     const retries = options.retries ?? 1;
-    return Promise.all(getServiceTargets().map((service) => checkServiceWithRetry(service.name, service.url, timeoutMs, retries)));
+    return Promise.all(getServiceTargets().map(t => checkServiceWithRetry(t, timeoutMs, retries)));
 }
 export function serializeServiceStatus(items) {
     return items.map((item) => ({
@@ -65,59 +70,69 @@ export function serializeServiceStatus(items) {
         statusCode: item.statusCode ?? null,
         latencyMs: item.latencyMs ?? null,
         error: item.error ?? null,
+        group: item.group ?? null,
+        intranet: item.intranet ?? false,
     }));
 }
 export function hasServiceFailures(items) {
-    return items.some((item) => !item.ok);
+    return items.some(item => !item.ok && !item.intranet);
 }
 export function countServiceHealth(items) {
     let up = 0;
     let down = 0;
-    for (const item of items) {
-        if (item.ok) {
-            up += 1;
-        }
-        else {
-            down += 1;
-        }
+    for (const item of items.filter(i => !i.intranet)) {
+        if (item.ok)
+            up++;
+        else
+            down++;
     }
     return { up, down };
 }
 export function renderServiceStatusTable(items, options) {
-    const color = options?.color !== false;
+    const useColor = options?.color !== false;
     const id = (s) => s;
-    const dim = color ? chalk.dim : id;
-    const green = color ? chalk.green : id;
-    const red = color ? chalk.red : id;
-    const cyan = color ? chalk.cyan : id;
+    const applyDim = useColor ? chalk.dim : id;
+    const applyGreen = useColor ? chalk.green : id;
+    const applyRed = useColor ? chalk.red : id;
+    const applyCyan = useColor ? chalk.cyan : id;
+    const applyLatency = useColor ? c.latency : (ms) => `${ms}ms`;
     const trans = t();
-    const nameWidth = 10;
-    const statusWidth = 9;
-    const latencyWidth = 10;
-    const h = pickIcon('─', '-');
-    const v = pickIcon('│', '|');
-    const topLeft = pickIcon('┌', '+');
-    const topMid = pickIcon('┬', '+');
-    const topRight = pickIcon('┐', '+');
-    const midLeft = pickIcon('├', '+');
-    const midMid = pickIcon('┼', '+');
-    const midRight = pickIcon('┤', '+');
-    const bottomLeft = pickIcon('└', '+');
-    const bottomMid = pickIcon('┴', '+');
-    const bottomRight = pickIcon('┘', '+');
-    const top = `${topLeft}${h.repeat(nameWidth + 2)}${topMid}${h.repeat(statusWidth + 2)}${topMid}${h.repeat(latencyWidth + 2)}${topRight}`;
-    const divider = `${midLeft}${h.repeat(nameWidth + 2)}${midMid}${h.repeat(statusWidth + 2)}${midMid}${h.repeat(latencyWidth + 2)}${midRight}`;
-    const bottom = `${bottomLeft}${h.repeat(nameWidth + 2)}${bottomMid}${h.repeat(statusWidth + 2)}${bottomMid}${h.repeat(latencyWidth + 2)}${bottomRight}`;
-    const header = `${v} ${padEndV(trans.status.service, nameWidth)} ${v} ${padEndV(trans.status.health, statusWidth)} ${v} ${padEndV(trans.status.latency, latencyWidth)} ${v}`;
-    const lines = [dim(top), header, dim(divider)];
+    const nameWidth = Math.max(...items.map(i => visualWidth(i.name)), visualWidth(trans.status.service));
+    const statusWidth = 10;
+    const onIcon = pickIcon('●', '+');
+    const offIcon = pickIcon('✕', '!');
+    const lanIcon = pickIcon('○', 'o');
+    const sep = pickIcon('─', '-');
+    const lines = [];
+    let currentGroup;
     for (const item of items) {
-        const statusLabel = item.ok
-            ? green(`${pickIcon('●', 'OK')} ${trans.status.up}`)
-            : red(`${pickIcon('●', '!!')} ${trans.status.down}`);
-        const latency = item.latencyMs != null ? `${item.latencyMs}ms` : '-';
-        lines.push(`${v} ${padEndV(cyan(item.name), nameWidth)} ${v} ${padEndV(statusLabel, statusWidth)} ${v} ${padEndV(latency, latencyWidth)} ${v}`);
+        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 : '';
+            lines.push(`  ${applyDim(groupLabel)}`);
+            lines.push(`  ${applyDim(sep.repeat(nameWidth + statusWidth + 12))}`);
+            currentGroup = item.group;
+        }
+        const nameCol = padEndV(item.intranet ? applyDim(item.name) : applyCyan(item.name), nameWidth);
+        let statusLabel;
+        if (item.ok) {
+            statusLabel = applyGreen(`${onIcon} ${trans.status.up}`);
+        }
+        else if (item.intranet) {
+            statusLabel = applyDim(`${lanIcon} ${trans.status.down}`);
+        }
+        else {
+            statusLabel = applyRed(`${offIcon} ${trans.status.down}`);
+        }
+        const statusCol = padEndV(statusLabel, statusWidth);
+        const latencyCol = item.ok && item.latencyMs != null
+            ? applyLatency(item.latencyMs)
+            : applyDim('—');
+        lines.push(`  ${nameCol}  ${statusCol}  ${latencyCol}`);
     }
-    lines.push(dim(bottom));
     return lines.join('\n');
 }
 export async function showServiceStatus() {
@@ -131,6 +146,8 @@ export async function showServiceStatus() {
     else {
         spinner.stop(trans.status.summaryOk);
     }
+    console.log();
     console.log(renderServiceStatusTable(items, { color: !!process.stdout.isTTY }));
+    console.log();
     return items;
 }

package/dist/i18n/locales/en.json

@@ -53,7 +53,12 @@
       "title": "Activity (last 12 months)",
       "legendLess": "Less",
       "legendMore": "More"
-    }
+    },
+    "pastLoading": "Loading past events...",
+    "pastEvents": "Past Events",
+    "pastEventsDesc": "Recent activity history",
+    "noPastEvents": "No past events in the last 30 days",
+    "viewPastDetail": "Select an event for details:"
   },
   "docs": {
     "loading": "Loading documentation list...",
@@ -87,6 +92,8 @@
     "browserError": "Failed to open browser",
     "browserErrorHint": "Please visit manually: https://docs.nbtca.space",
     "retry": "Retry?",
+    "tocTitle": "Table of Contents",
+    "tableHint": "tables render better in browser",
     "endOfDocument": "End of document - Press q to quit",
     "githubRateLimited": "GitHub API rate limit reached. Resets at {time}.",
     "githubForbidden": "GitHub API access denied (403).",
@@ -119,13 +126,19 @@
     "code": "Code",
     "latency": "Latency",
     "url": "URL",
-    "up": "UP",
-    "down": "DOWN",
-    "serviceWebsite": "Website",
+    "up": "online",
+    "down": "offline",
+    "groupNbtca": "NBTCA Services",
+    "groupExternal": "External",
+    "groupIntranet": "Intranet (LAN only)",
+    "serviceHomepage": "Homepage",
     "serviceDocs": "Docs",
-    "serviceCalendar": "Calendar",
+    "serviceIcal": "iCal Feed",
+    "serviceRepair": "Repair",
     "serviceGithub": "GitHub",
     "serviceRoadmap": "Roadmap",
+    "serviceCloud": "Cloud",
+    "serviceMirror": "Mirror",
     "watchStarted": "Starting status watch (every {seconds}s)",
     "watchUpdated": "Last updated",
     "watchHint": "Press Ctrl+C to stop",

package/dist/i18n/locales/zh.json

@@ -53,7 +53,12 @@
       "title": "近一年活跃度",
       "legendLess": "少",
       "legendMore": "多"
-    }
+    },
+    "pastLoading": "正在加载历史活动...",
+    "pastEvents": "历史活动",
+    "pastEventsDesc": "近期活动记录",
+    "noPastEvents": "最近 30 天内暂无历史活动",
+    "viewPastDetail": "选择活动查看详情:"
   },
   "docs": {
     "loading": "正在加载文档列表...",
@@ -87,6 +92,8 @@
     "browserError": "无法打开浏览器",
     "browserErrorHint": "请手动访问: https://docs.nbtca.space",
     "retry": "是否重试？",
+    "tocTitle": "目录",
+    "tableHint": "表格在浏览器中效果更佳",
     "endOfDocument": "文档结束 - 按 q 退出",
     "githubRateLimited": "GitHub API 速率限制已达上限，将在 {time} 重置。",
     "githubForbidden": "GitHub API 拒绝访问 (403)。",
@@ -119,13 +126,19 @@
     "code": "代码",
     "latency": "延迟",
     "url": "URL",
-    "up": "正常",
-    "down": "异常",
-    "serviceWebsite": "官网",
+    "up": "在线",
+    "down": "离线",
+    "groupNbtca": "NBTCA 服务",
+    "groupExternal": "外部平台",
+    "groupIntranet": "内网服务（仅校园网）",
+    "serviceHomepage": "主页",
     "serviceDocs": "文档",
-    "serviceCalendar": "日历",
+    "serviceIcal": "iCal 源",
+    "serviceRepair": "维修服务",
     "serviceGithub": "GitHub",
-    "serviceRoadmap": "看板",
+    "serviceRoadmap": "路线图",
+    "serviceCloud": "云存储",
+    "serviceMirror": "镜像站",
     "watchStarted": "开始监控服务状态（每 {seconds} 秒）",
     "watchUpdated": "最近更新",
     "watchHint": "按 Ctrl+C 停止",

package/dist/main.js

@@ -1,42 +1,29 @@
-/**
- * NBTCA Welcome Tool
- * Minimalist startup flow
- */
-import chalk from 'chalk';
-import { intro } from '@clack/prompts';
 import { printLogo } from './core/logo.js';
 import { clearScreen, handleGracefulExit } from './core/ui.js';
 import { showMainMenu } from './core/menu.js';
-import { APP_INFO } from './config/data.js';
+import { c } from './core/theme.js';
 import { enableVimKeys } from './core/vim-keys.js';
 import { checkForUpdate } from './features/update.js';
-/**
- * Main program entry point
- */
+import { showEventsPreview } from './features/calendar.js';
 export async function main(options = {}) {
     try {
-        // Enable Vim key bindings
         enableVimKeys();
-        // Clear screen
         if (process.stdout.isTTY) {
             clearScreen();
         }
-        // Display logo (smart fallback)
         if (!options.skipLogo) {
             printLogo();
         }
-        // Non-blocking update check (fire and forget, print before menu if resolved in time)
+        // Fire update check in background; events fetch provides natural wait time
         const updatePromise = checkForUpdate();
-        // Open session frame
-        intro(chalk.cyan('NBTCA Prompt') + chalk.dim(` v${APP_INFO.version}`));
-        // Show update notification if ready
+        await showEventsPreview();
+        // Update check is very likely done by now; give it a short window if not
         const updateMsg = await Promise.race([
             updatePromise,
-            new Promise(r => setTimeout(r, 500, null)),
+            new Promise(r => setTimeout(r, 100, null)),
         ]);
         if (updateMsg)
-            console.log(chalk.yellow(updateMsg));
-        // Show main menu (loop)
+            console.log(c.warn(updateMsg));
         await showMainMenu();
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbtca/prompt",
-  "version": "1.1.3",
+  "version": "1.3.0",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -39,8 +39,8 @@
   ],
   "dependencies": {
     "@clack/prompts": "^1.2.0",
-    "@nbtca/docs": "^0.1.2",
-    "@nbtca/nbtcal": "^0.2.1",
+    "@nbtca/docs": "^0.2.0",
+    "@nbtca/nbtcal": "^0.3.0",
     "chalk": "^5.6.2",
     "gradient-string": "^3.0.0",
     "marked": "^15.0.12",