@nbtca/prompt 1.0.24 → 1.0.25

package/dist/config/paths.js

@@ -1,5 +1,24 @@
-import path from 'path';
+import { existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+function getXdgConfigDir() {
+    const xdgHome = process.env['XDG_CONFIG_HOME'] || join(homedir(), '.config');
+    return join(xdgHome, 'nbtca');
+}
+function getLegacyConfigDir() {
+    return join(homedir(), '.nbtca');
+}
 export function getConfigDir() {
-    const homeDir = process.env['HOME'] || process.env['USERPROFILE'] || '';
-    return path.join(homeDir, '.nbtca');
+    const xdgDir = getXdgConfigDir();
+    if (existsSync(xdgDir))
+        return xdgDir;
+    const legacyDir = getLegacyConfigDir();
+    if (existsSync(legacyDir))
+        return legacyDir;
+    return xdgDir;
+}
+export function getWritableConfigDir() {
+    const dir = getXdgConfigDir();
+    mkdirSync(dir, { recursive: true });
+    return dir;
 }

package/dist/config/preferences.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { getConfigDir } from './paths.js';
+import { getConfigDir, getWritableConfigDir } from './paths.js';
 const DEFAULT_PREFERENCES = {
     iconMode: 'auto',
     colorMode: 'auto',
@@ -8,11 +8,8 @@ const DEFAULT_PREFERENCES = {
 function getPreferencesPath() {
     return path.join(getConfigDir(), 'preferences.json');
 }
-function ensureConfigDir() {
-    const configDir = getConfigDir();
-    if (!fs.existsSync(configDir)) {
-        fs.mkdirSync(configDir, { recursive: true });
-    }
+function getWritablePreferencesPath() {
+    return path.join(getWritableConfigDir(), 'preferences.json');
 }
 export function loadPreferences() {
     try {
@@ -32,8 +29,7 @@ export function loadPreferences() {
 }
 function savePreferences(preferences) {
     try {
-        ensureConfigDir();
-        fs.writeFileSync(getPreferencesPath(), JSON.stringify(preferences, null, 2));
+        fs.writeFileSync(getWritablePreferencesPath(), JSON.stringify(preferences, null, 2));
         return true;
     }
     catch {

package/dist/core/text.js

@@ -1,17 +1,20 @@
 /** Width of a single Unicode character: 2 for CJK/fullwidth, 1 otherwise. */
 function charWidth(ch) {
     const cp = ch.codePointAt(0) ?? 0;
-    return ((cp >= 0x1100 && cp <= 0x115F) || // Hangul Jamo
-        (cp >= 0x2E80 && cp <= 0x303F) || // CJK Radicals / Kangxi
-        (cp >= 0x3040 && cp <= 0x33FF) || // Japanese kana + CJK symbols
-        (cp >= 0x3400 && cp <= 0x4DBF) || // CJK Extension A
-        (cp >= 0x4E00 && cp <= 0x9FFF) || // CJK Unified Ideographs
-        (cp >= 0xAC00 && cp <= 0xD7AF) || // Hangul Syllables
-        (cp >= 0xF900 && cp <= 0xFAFF) || // CJK Compatibility Ideographs
-        (cp >= 0xFE30 && cp <= 0xFE4F) || // CJK Compatibility Forms
-        (cp >= 0xFF00 && cp <= 0xFF60) || // Fullwidth Forms
-        (cp >= 0xFFE0 && cp <= 0xFFE6) // Fullwidth Signs
-    ) ? 2 : 1;
+    return ((cp >= 0x1100 && cp <= 0x115F) ||
+        (cp >= 0x2E80 && cp <= 0x303F) ||
+        (cp >= 0x3040 && cp <= 0x33FF) ||
+        (cp >= 0x3400 && cp <= 0x4DBF) ||
+        (cp >= 0x4E00 && cp <= 0x9FFF) ||
+        (cp >= 0xAC00 && cp <= 0xD7AF) ||
+        (cp >= 0xF900 && cp <= 0xFAFF) ||
+        (cp >= 0xFE30 && cp <= 0xFE4F) ||
+        (cp >= 0xFF00 && cp <= 0xFF60) ||
+        (cp >= 0xFFE0 && cp <= 0xFFE6) ||
+        (cp >= 0x20000 && cp <= 0x2A6DF) ||
+        (cp >= 0x2A700 && cp <= 0x2CEAF) ||
+        (cp >= 0x2CEB0 && cp <= 0x2EBEF) ||
+        (cp >= 0x30000 && cp <= 0x323AF)) ? 2 : 1;
 }
 /** Strip ANSI escape sequences from a string. */
 // eslint-disable-next-line no-control-regex

package/dist/core/ui.js

@@ -5,6 +5,7 @@
 import { log, spinner as clackSpinner } from '@clack/prompts';
 import chalk from 'chalk';
 import { pickIcon } from './icons.js';
+import { t } from '../i18n/index.js';
 /**
  * Display success message
  */
@@ -62,3 +63,18 @@ export function createSpinner(msg) {
     s.start(msg);
     return s;
 }
+export function handleGracefulExit(err) {
+    const message = err instanceof Error ? err.message : String(err ?? '');
+    if (message.includes('SIGINT') || message.includes('User force closed')) {
+        console.log();
+        console.log(chalk.dim(t().common.goodbye));
+        process.exit(0);
+    }
+    if (message) {
+        console.error(message);
+    }
+    else {
+        console.error('Error occurred:', err);
+    }
+    process.exit(1);
+}

package/dist/core/vim-keys.js

@@ -14,13 +14,17 @@ const VIM_TO_SEQ = {
     G: Buffer.from('\u001b[F'), // end (last item)
     q: Buffer.from('\u0003'), // quit
 };
+let vimActive = true;
+export function setVimKeysActive(active) {
+    vimActive = active;
+}
 export function enableVimKeys() {
     const stdin = process.stdin;
     if (!stdin.isTTY)
         return;
     const originalEmit = stdin.emit.bind(stdin);
     stdin.emit = function (event, ...args) {
-        if (event === 'data') {
+        if (event === 'data' && vimActive) {
             const chunk = args[0];
             if (Buffer.isBuffer(chunk) && chunk.length === 1) {
                 const seq = VIM_TO_SEQ[String.fromCharCode(chunk[0])];

package/dist/features/calendar.js

@@ -2,7 +2,6 @@
  * ICS calendar module
  * Fetches and renders upcoming events with Unicode box table.
  */
-import axios from 'axios';
 import ICAL from 'ical.js';
 import chalk from 'chalk';
 import { select, isCancel } from '@clack/prompts';
@@ -13,13 +12,17 @@ import { t } from '../i18n/index.js';
 import { APP_INFO, URLS } from '../config/data.js';
 export async function fetchEvents() {
     try {
-        const response = await axios.get('https://ical.nbtca.space', {
-            timeout: 5000,
-            headers: {
-                'User-Agent': `NBTCA-CLI/${APP_INFO.version}`
-            }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const response = await fetch('https://ical.nbtca.space', {
+            signal: controller.signal,
+            headers: { 'User-Agent': `NBTCA-CLI/${APP_INFO.version}` },
         });
-        const jcalData = ICAL.parse(response.data);
+        clearTimeout(timeout);
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        const data = await response.text();
+        const jcalData = ICAL.parse(data);
         const comp = new ICAL.Component(jcalData);
         const vevents = comp.getAllSubcomponents('vevent');
         const events = [];
@@ -46,7 +49,9 @@ export async function fetchEvents() {
         return events;
     }
     catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
+        const detail = err instanceof Error
+            ? (err.name === 'AbortError' ? 'Request timed out' : err.message)
+            : String(err);
         throw new Error(`${t().calendar.error}: ${detail}`);
     }
 }
@@ -61,8 +66,12 @@ export function serializeEvents(events) {
     }));
 }
 function formatDate(date) {
+    const now = new Date();
     const month = String(date.getMonth() + 1).padStart(2, '0');
     const day = String(date.getDate()).padStart(2, '0');
+    if (date.getFullYear() !== now.getFullYear()) {
+        return `${date.getFullYear()}-${month}-${day}`;
+    }
     return `${month}-${day}`;
 }
 function formatTime(date) {
@@ -78,7 +87,7 @@ export function renderEventsTable(events, options) {
     const color = options?.color !== false;
     if (events.length === 0)
         return trans.calendar.noEvents;
-    const dateWidth = 13;
+    const dateWidth = 16;
     const titleWidth = 30;
     const locationWidth = 16;
     const h = pickIcon('─', '-');

package/dist/features/docs.js

@@ -2,7 +2,6 @@
  * 知识库终端查看模块
  * 获取并渲染Markdown文档
  */
-import axios from 'axios';
 import { marked } from 'marked';
 import TerminalRenderer from 'marked-terminal';
 import chalk from 'chalk';
@@ -12,7 +11,8 @@ import { error, warning, success, createSpinner } from '../core/ui.js';
 import { pickIcon } from '../core/icons.js';
 import { spawn, execFileSync } from 'child_process';
 import { APP_INFO, GITHUB_REPO, URLS } from '../config/data.js';
-import { t } from '../i18n/index.js';
+import { t, fmt } from '../i18n/index.js';
+import { setVimKeysActive } from '../core/vim-keys.js';
 function detectTerminalType() {
     const term = (process.env['TERM'] || '').toLowerCase();
     const termProgram = (process.env['TERM_PROGRAM'] || '').toLowerCase();
@@ -55,8 +55,9 @@ function ensureMarkedConfigured() {
     if (_markedConfigured)
         return;
     _markedConfigured = true;
-    // @ts-ignore - marked v11 / marked-terminal v7 type incompatibility
-    marked.setOptions({ renderer: new TerminalRenderer(getRendererOptions(getTerminalType())) });
+    marked.use({
+        renderer: new TerminalRenderer(getRendererOptions(getTerminalType()))
+    });
 }
 // ─── marked-terminal renderer ─────────────────────────────────────────────────
 function getRendererOptions(type) {
@@ -135,6 +136,18 @@ function getAnyCacheValue(cache, key) {
 function setCacheValue(cache, key, value, ttlMs) {
     cache.set(key, { value, expiresAt: Date.now() + ttlMs });
 }
+const DIR_CACHE_MAX = 30;
+const FILE_CACHE_MAX = 50;
+const RENDER_CACHE_MAX = 50;
+function evictStalest(cache, maxSize) {
+    if (cache.size <= maxSize)
+        return;
+    const oldest = [...cache.entries()]
+        .sort((a, b) => a[1].expiresAt - b[1].expiresAt)
+        .slice(0, cache.size - maxSize);
+    for (const [key] of oldest)
+        cache.delete(key);
+}
 function contentFingerprint(content) {
     const head = content.slice(0, 80);
     const tail = content.slice(-80);
@@ -157,12 +170,29 @@ async function fetchGitHubDirectory(path = '', options = {}) {
     try {
         const headers = {
             'Accept': 'application/vnd.github.v3+json',
-            'User-Agent': `NBTCA-CLI/${APP_INFO.version}`
+            'User-Agent': `NBTCA-CLI/${APP_INFO.version}`,
         };
         if (GITHUB_TOKEN)
             headers['Authorization'] = `Bearer ${GITHUB_TOKEN}`;
-        const response = await axios.get(url, { timeout: 10000, headers });
-        const items = response.data
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 10000);
+        const response = await fetch(url, { signal: controller.signal, headers });
+        clearTimeout(timeout);
+        if (!response.ok) {
+            const trans = t();
+            if (response.status === 403) {
+                const rateLimitRemaining = response.headers.get('x-ratelimit-remaining');
+                const rateLimitReset = response.headers.get('x-ratelimit-reset');
+                if (rateLimitRemaining === '0' && rateLimitReset) {
+                    const resetDate = new Date(Number.parseInt(rateLimitReset, 10) * 1000);
+                    throw new Error(`${fmt(trans.docs.githubRateLimited, { time: resetDate.toLocaleTimeString() })}\n${trans.docs.githubTokenHint}`);
+                }
+                throw new Error(`${trans.docs.githubForbidden}\n${trans.docs.githubTokenHint}`);
+            }
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = (await response.json());
+        const items = data
             .filter((item) => !item.name.startsWith('.') &&
             !SKIP_NAMES.has(item.name) &&
             !(item.type === 'file' && !item.name.endsWith('.md')))
@@ -180,6 +210,7 @@ async function fetchGitHubDirectory(path = '', options = {}) {
             return a.name.localeCompare(b.name);
         });
         setCacheValue(dirCache, cacheKey, items, DIR_CACHE_TTL_MS);
+        evictStalest(dirCache, DIR_CACHE_MAX);
         return { data: items, fromCache: false, staleFallback: false };
     }
     catch (err) {
@@ -188,18 +219,10 @@ async function fetchGitHubDirectory(path = '', options = {}) {
             return { data: staleCached, fromCache: true, staleFallback: true };
         }
         const trans = t();
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        const axiosErr = err;
-        if (axiosErr.response?.status === 403) {
-            const rateLimitRemaining = axiosErr.response.headers?.['x-ratelimit-remaining'];
-            const rateLimitReset = axiosErr.response.headers?.['x-ratelimit-reset'];
-            if (rateLimitRemaining === '0' && rateLimitReset) {
-                const resetDate = new Date(Number.parseInt(rateLimitReset, 10) * 1000);
-                throw new Error(`${trans.docs.githubRateLimited.replace('{time}', resetDate.toLocaleTimeString())}\n${trans.docs.githubTokenHint}`);
-            }
-            throw new Error(`${trans.docs.githubForbidden}\n${trans.docs.githubTokenHint}`);
-        }
-        throw new Error(trans.docs.fetchDirFailed.replace('{error}', errorMessage));
+        const errorMessage = err instanceof Error
+            ? (err.name === 'AbortError' ? 'Request timed out' : err.message)
+            : String(err);
+        throw new Error(fmt(trans.docs.fetchDirFailed, { error: errorMessage }));
     }
 }
 async function fetchGitHubRawContent(path, options = {}) {
@@ -211,9 +234,18 @@ async function fetchGitHubRawContent(path, options = {}) {
     }
     const url = `https://raw.githubusercontent.com/${GITHUB_REPO.owner}/${GITHUB_REPO.repo}/${GITHUB_REPO.branch}/${path}`;
     try {
-        const response = await axios.get(url, { timeout: 15000, headers: { 'User-Agent': `NBTCA-CLI/${APP_INFO.version}` } });
-        const content = String(response.data);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15000);
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: { 'User-Agent': `NBTCA-CLI/${APP_INFO.version}` },
+        });
+        clearTimeout(timeout);
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        const content = await response.text();
         setCacheValue(fileCache, path, content, FILE_CACHE_TTL_MS);
+        evictStalest(fileCache, FILE_CACHE_MAX);
         return { data: content, fromCache: false, staleFallback: false };
     }
     catch (err) {
@@ -222,8 +254,10 @@ async function fetchGitHubRawContent(path, options = {}) {
             return { data: staleCached, fromCache: true, staleFallback: true };
         }
         const trans = t();
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        throw new Error(trans.docs.fetchFileFailed.replace('{error}', errorMessage));
+        const errorMessage = err instanceof Error
+            ? (err.name === 'AbortError' ? 'Request timed out' : err.message)
+            : String(err);
+        throw new Error(fmt(trans.docs.fetchFileFailed, { error: errorMessage }));
     }
 }
 // ─── Content cleaning ─────────────────────────────────────────────────────────
@@ -361,22 +395,41 @@ async function displayWithLess(rendered, title, filePath, readTime) {
     });
 }
 // ─── Directory browser ────────────────────────────────────────────────────────
-async function browseDirectory(dirPath = '') {
-    const trans = t();
-    try {
-        const s = createSpinner(dirPath ? `${trans.docs.loadingDir}: ${dirPath}` : trans.docs.loading);
-        const result = await fetchGitHubDirectory(dirPath);
-        const items = result.data;
-        s.stop(dirPath || trans.docs.chooseDoc);
-        if (result.staleFallback) {
-            warning(trans.docs.usingCachedData);
+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);
+            const result = await fetchGitHubDirectory(currentPath);
+            items = result.data;
+            s.stop(currentPath || trans.docs.chooseDoc);
+            if (result.staleFallback) {
+                warning(trans.docs.usingCachedData);
+            }
+        }
+        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 = [
-            ...(dirPath ? [{ value: '__back__', label: chalk.dim(trans.docs.upToParent) }] : []),
+            ...(currentPath ? [{ value: '__back__', label: chalk.dim(trans.docs.upToParent) }] : []),
             ...items.map(item => ({
                 value: item.path,
                 label: item.type === 'dir'
@@ -387,93 +440,89 @@ async function browseDirectory(dirPath = '') {
             { value: '__exit__', label: chalk.dim(trans.docs.returnToMenu) },
         ];
         const selected = await select({
-            message: dirPath ? `${trans.docs.currentDir}: ${dirPath}` : trans.docs.chooseDoc,
+            message: currentPath ? `${trans.docs.currentDir}: ${currentPath}` : trans.docs.chooseDoc,
             options,
         });
         if (isCancel(selected) || selected === '__exit__')
             return;
         if (selected === '__back__') {
-            const parentPath = dirPath.split('/').slice(0, -1).join('/');
-            await browseDirectory(parentPath);
+            currentPath = currentPath.split('/').slice(0, -1).join('/');
+            continue;
         }
-        else {
-            const item = items.find(i => i.path === selected);
-            if (item?.type === 'dir') {
-                await browseDirectory(selected);
-            }
-            else if (item?.type === 'file') {
-                await viewMarkdownFile(selected);
-                await browseDirectory(dirPath);
-            }
+        const item = items.find(i => i.path === selected);
+        if (item?.type === 'dir') {
+            currentPath = selected;
+            continue;
         }
-    }
-    catch (err) {
-        error(trans.docs.loadError);
-        const errMsg = err instanceof Error ? err.message : String(err);
-        console.log(chalk.gray(`  ${trans.docs.errorHint}: ${errMsg}`));
-        const retry = await confirm({ message: trans.docs.retry });
-        if (!isCancel(retry) && retry) {
-            await browseDirectory(dirPath);
+        if (item?.type === 'file') {
+            await viewMarkdownFile(selected);
         }
     }
 }
 // ─── Document viewer ──────────────────────────────────────────────────────────
 async function viewMarkdownFile(filePath) {
     const trans = t();
-    try {
-        ensureMarkedConfigured();
-        const s = createSpinner(`${trans.docs.loading.replace('...', '')}: ${filePath}`);
-        const rawResult = await fetchGitHubRawContent(filePath);
-        if (rawResult.staleFallback) {
-            warning(trans.docs.usingCachedData);
-        }
-        const rawContent = rawResult.data;
-        const fingerprint = contentFingerprint(rawContent);
-        const cachedRendered = getFreshCacheValue(renderCache, filePath);
-        let renderedDoc;
-        if (cachedRendered && cachedRendered.fingerprint === fingerprint) {
-            renderedDoc = cachedRendered;
-        }
-        else {
-            const cleaned = cleanMarkdownContent(rawContent, getTerminalType());
-            const title = extractDocTitle(rawContent, cleaned) || filePath.split('/').pop() || filePath;
-            const readTime = estimateReadTime(cleaned);
-            const rendered = await marked(cleaned);
-            renderedDoc = { fingerprint, cleaned, rendered, title, readTime };
-            setCacheValue(renderCache, filePath, renderedDoc, RENDER_CACHE_TTL_MS);
-        }
-        s.stop(`${chalk.bold(renderedDoc.title)}  ${chalk.dim(renderedDoc.readTime)}`);
-        if (hasGlow()) {
-            await displayWithGlow(renderedDoc.cleaned);
-        }
-        else {
-            await displayWithLess(renderedDoc.rendered, renderedDoc.title, filePath, renderedDoc.readTime);
+    while (true) {
+        try {
+            ensureMarkedConfigured();
+            const s = createSpinner(`${trans.docs.loading.replace('...', '')}: ${filePath}`);
+            const rawResult = await fetchGitHubRawContent(filePath);
+            if (rawResult.staleFallback) {
+                warning(trans.docs.usingCachedData);
+            }
+            const rawContent = rawResult.data;
+            const fingerprint = contentFingerprint(rawContent);
+            const cachedRendered = getFreshCacheValue(renderCache, filePath);
+            let renderedDoc;
+            if (cachedRendered && cachedRendered.fingerprint === fingerprint) {
+                renderedDoc = cachedRendered;
+            }
+            else {
+                const cleaned = cleanMarkdownContent(rawContent, getTerminalType());
+                const title = extractDocTitle(rawContent, cleaned) || filePath.split('/').pop() || filePath;
+                const readTime = estimateReadTime(cleaned);
+                const rendered = await marked(cleaned);
+                renderedDoc = { fingerprint, cleaned, rendered, title, readTime };
+                setCacheValue(renderCache, filePath, renderedDoc, RENDER_CACHE_TTL_MS);
+                evictStalest(renderCache, RENDER_CACHE_MAX);
+            }
+            s.stop(`${chalk.bold(renderedDoc.title)}  ${chalk.dim(renderedDoc.readTime)}`);
+            if (hasGlow()) {
+                await displayWithGlow(renderedDoc.cleaned);
+            }
+            else {
+                await displayWithLess(renderedDoc.rendered, renderedDoc.title, filePath, renderedDoc.readTime);
+            }
+            console.log();
+            success(trans.docs.docCompleted);
+            console.log();
+            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 },
+                ],
+            });
+            if (isCancel(action) || action === 'back')
+                return;
+            if (action === 'browser') {
+                await openDocsInBrowser(filePath);
+                return;
+            }
+            // action === 'reread' → continue loop
         }
-        console.log();
-        success(trans.docs.docCompleted);
-        console.log();
-        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 },
-            ],
-        });
-        if (isCancel(action))
+        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 openBrowser = await confirm({ message: trans.docs.openBrowserPrompt });
+            setVimKeysActive(true);
+            if (!isCancel(openBrowser) && openBrowser) {
+                await openDocsInBrowser(filePath);
+            }
             return;
-        if (action === 'browser')
-            await openDocsInBrowser(filePath);
-        if (action === 'reread')
-            await viewMarkdownFile(filePath);
-    }
-    catch (err) {
-        error(trans.docs.loadError);
-        const errMsg = err instanceof Error ? err.message : String(err);
-        console.log(chalk.gray(`  ${trans.docs.errorHint}: ${errMsg}`));
-        const openBrowser = await confirm({ message: trans.docs.openBrowserPrompt });
-        if (!isCancel(openBrowser) && openBrowser) {
-            await openDocsInBrowser(filePath);
         }
     }
 }
@@ -497,10 +546,12 @@ export async function openDocsInBrowser(path) {
 // ─── Search ────────────────────────────────────────────────────────────────────
 async function searchDocs() {
     const trans = t();
+    setVimKeysActive(false);
     const query = await text({
         message: trans.docs.searchPrompt,
         placeholder: trans.docs.searchPlaceholder,
     });
+    setVimKeysActive(true);
     if (isCancel(query) || !query.trim())
         return;
     const keyword = query.trim().toLowerCase();
@@ -523,6 +574,15 @@ async function searchDocs() {
                 }
             }
         }
+        // Also search already-cached file content
+        for (const [cachedPath, entry] of fileCache) {
+            if (results.some(r => r.path === cachedPath))
+                continue;
+            if (entry.value.toLowerCase().includes(keyword)) {
+                const name = cachedPath.split('/').pop() || cachedPath;
+                results.push({ name, path: cachedPath, category: trans.docs.searchResults });
+            }
+        }
         s.stop(`${results.length} ${trans.docs.searchResults}`);
     }
     catch {

package/dist/features/links.js

@@ -35,8 +35,3 @@ export async function showLinksMenu() {
         return;
     await openUrl(selected);
 }
-/** Direct openers for CLI non-interactive mode */
-export async function openHomepage() { await openUrl(URLS.homepage); }
-export async function openGithub() { await openUrl(URLS.github); }
-export async function openRoadmap() { await openUrl(URLS.roadmap); }
-export async function openRepairService() { await openUrl(URLS.repair); }

package/dist/features/status.js

@@ -1,4 +1,3 @@
-import axios from 'axios';
 import chalk from 'chalk';
 import { APP_INFO, URLS } from '../config/data.js';
 import { pickIcon } from '../core/icons.js';
@@ -18,19 +17,23 @@ function getServiceTargets() {
 async function checkService(name, url, timeoutMs) {
     const start = Date.now();
     try {
-        const response = await axios.get(url, {
-            timeout: timeoutMs,
-            maxRedirects: 5,
-            validateStatus: () => true,
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const 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.message : String(err);
+        const error = err instanceof Error
+            ? (err.name === 'AbortError' ? 'Request timed out' : err.message)
+            : String(err);
         return { name, url, ok: false, latencyMs, error };
     }
 }

package/dist/features/update.js

@@ -4,7 +4,7 @@
  */
 import chalk from 'chalk';
 import { APP_INFO } from '../config/data.js';
-import { t } from '../i18n/index.js';
+import { t, fmt } from '../i18n/index.js';
 const NPM_REGISTRY_URL = `https://registry.npmjs.org/@nbtca/prompt/latest`;
 /**
  * Fetch latest version from npm registry.
@@ -52,7 +52,7 @@ export async function checkForUpdate() {
     if (!latest || !isNewer(APP_INFO.version, latest))
         return null;
     const trans = t();
-    return `${trans.update.available.replace('{latest}', latest).replace('{current}', APP_INFO.version)}  ${chalk.dim(trans.update.command)}`;
+    return `${fmt(trans.update.available, { latest, current: APP_INFO.version })}  ${chalk.dim(trans.update.command)}`;
 }
 /**
  * Explicit update check command (nbtca update).
@@ -65,10 +65,10 @@ export async function runUpdateCheck() {
         return;
     }
     if (isNewer(APP_INFO.version, latest)) {
-        console.log(chalk.yellow(`${trans.update.available.replace('{latest}', latest).replace('{current}', APP_INFO.version)}`));
+        console.log(chalk.yellow(`${fmt(trans.update.available, { latest, current: APP_INFO.version })}`));
         console.log(chalk.dim(trans.update.command));
     }
     else {
-        console.log(chalk.green(`${trans.update.upToDate.replace('{version}', APP_INFO.version)}`));
+        console.log(chalk.green(`${fmt(trans.update.upToDate, { version: APP_INFO.version })}`));
     }
 }

package/dist/i18n/index.js

@@ -6,7 +6,7 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
-import { getConfigDir } from '../config/paths.js';
+import { getConfigDir, getWritableConfigDir } from '../config/paths.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -14,11 +14,17 @@ const __dirname = dirname(__filename);
  */
 let currentLanguage = 'zh'; // Default to Chinese
 /**
- * Get language configuration file path
+ * Get language configuration file path (read, with legacy fallback)
  */
 function getLanguageConfigPath() {
     return path.join(getConfigDir(), 'language.json');
 }
+/**
+ * Get writable language configuration file path (XDG, creates dir)
+ */
+function getWritableLanguageConfigPath() {
+    return path.join(getWritableConfigDir(), 'language.json');
+}
 /**
  * Load language preference from config file
  */
@@ -40,11 +46,7 @@ export function loadLanguagePreference() {
  */
 export function saveLanguagePreference(language) {
     try {
-        const configDir = getConfigDir();
-        if (!fs.existsSync(configDir)) {
-            fs.mkdirSync(configDir, { recursive: true });
-        }
-        const configPath = getLanguageConfigPath();
+        const configPath = getWritableLanguageConfigPath();
         fs.writeFileSync(configPath, JSON.stringify({ language }, null, 2));
         currentLanguage = language;
         return true;
@@ -95,6 +97,12 @@ export function t() {
     }
     return translationsCache.get(currentLanguage);
 }
+export function fmt(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => {
+        const val = vars[key];
+        return val !== undefined ? String(val) : `{${key}}`;
+    });
+}
 /**
  * Clear translation cache (useful when switching languages)
  */

package/dist/index.js

@@ -10,8 +10,8 @@ import { pickIcon } from './core/icons.js';
 import { applyColorModePreference } from './config/preferences.js';
 import { openDocsInBrowser } from './features/docs.js';
 import { runThemeCommand } from './features/theme.js';
-import { setLanguage, t } from './i18n/index.js';
-import { clearScreen } from './core/ui.js';
+import { setLanguage, t, fmt } from './i18n/index.js';
+import { clearScreen, handleGracefulExit } from './core/ui.js';
 import { APP_INFO, URLS } from './config/data.js';
 import { runUpdateCheck } from './features/update.js';
 const ACTION_ALIASES = {
@@ -169,8 +169,12 @@ async function runEventsCommand(flags) {
     let events = await fetchEvents();
     if (flags.has('--today')) {
         const now = new Date();
-        const todayStr = `${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
-        events = events.filter(e => e.date === todayStr);
+        events = events.filter(e => {
+            const d = e.startDate;
+            return d.getFullYear() === now.getFullYear() &&
+                d.getMonth() === now.getMonth() &&
+                d.getDate() === now.getDate();
+        });
     }
     const nextFlag = Array.from(flags).find(f => f.startsWith('--next='));
     if (nextFlag) {
@@ -202,11 +206,11 @@ async function runStatusCommand(flags) {
         process.exit(1);
     }
     if (!Number.isInteger(timeoutMs) || timeoutMs < STATUS_TIMEOUT_MIN || timeoutMs > STATUS_TIMEOUT_MAX) {
-        console.error(chalk.red(trans.status.invalidTimeout.replace('{min}', String(STATUS_TIMEOUT_MIN)).replace('{max}', String(STATUS_TIMEOUT_MAX))));
+        console.error(chalk.red(fmt(trans.status.invalidTimeout, { min: STATUS_TIMEOUT_MIN, max: STATUS_TIMEOUT_MAX })));
         process.exit(1);
     }
     if (!Number.isInteger(retries) || retries < STATUS_RETRIES_MIN || retries > STATUS_RETRIES_MAX) {
-        console.error(chalk.red(trans.status.invalidRetries.replace('{min}', String(STATUS_RETRIES_MIN)).replace('{max}', String(STATUS_RETRIES_MAX))));
+        console.error(chalk.red(fmt(trans.status.invalidRetries, { min: STATUS_RETRIES_MIN, max: STATUS_RETRIES_MAX })));
         process.exit(1);
     }
     if (watch && flags.has('--json')) {
@@ -214,7 +218,7 @@ async function runStatusCommand(flags) {
         process.exit(1);
     }
     if (watch && (!Number.isInteger(intervalSeconds) || intervalSeconds < STATUS_WATCH_INTERVAL_MIN || intervalSeconds > STATUS_WATCH_INTERVAL_MAX)) {
-        console.error(chalk.red(trans.status.invalidInterval.replace('{min}', String(STATUS_WATCH_INTERVAL_MIN)).replace('{max}', String(STATUS_WATCH_INTERVAL_MAX))));
+        console.error(chalk.red(fmt(trans.status.invalidInterval, { min: STATUS_WATCH_INTERVAL_MIN, max: STATUS_WATCH_INTERVAL_MAX })));
         process.exit(1);
     }
     if (watch && !hasInteractiveTerminal()) {
@@ -225,7 +229,7 @@ async function runStatusCommand(flags) {
         let stopped = false;
         const onSigint = () => { stopped = true; };
         process.once('SIGINT', onSigint);
-        console.log(chalk.dim(`${trans.status.watchStarted.replace('{seconds}', String(intervalSeconds))} | ${trans.status.watchHint}`));
+        console.log(chalk.dim(`${fmt(trans.status.watchStarted, { seconds: intervalSeconds })} | ${trans.status.watchHint}`));
         try {
             while (!stopped) {
                 const services = await checkServices({ timeoutMs, retries });
@@ -394,17 +398,4 @@ async function runCommandMode(argv) {
         return;
     }
 }
-runCommandMode(process.argv.slice(2)).catch((err) => {
-    if (err?.message?.includes('SIGINT') || err?.message?.includes('User force closed')) {
-        console.log();
-        console.log(chalk.dim(t().common.goodbye));
-        process.exit(0);
-    }
-    if (err?.message) {
-        console.error(err.message);
-    }
-    else {
-        console.error('Error occurred:', err);
-    }
-    process.exit(1);
-});
+runCommandMode(process.argv.slice(2)).catch(handleGracefulExit);

package/dist/main.js

@@ -5,11 +5,10 @@
 import chalk from 'chalk';
 import { intro } from '@clack/prompts';
 import { printLogo } from './core/logo.js';
-import { clearScreen } from './core/ui.js';
+import { clearScreen, handleGracefulExit } from './core/ui.js';
 import { showMainMenu } from './core/menu.js';
 import { APP_INFO } from './config/data.js';
 import { enableVimKeys } from './core/vim-keys.js';
-import { t } from './i18n/index.js';
 import { checkForUpdate } from './features/update.js';
 /**
  * Main program entry point
@@ -41,15 +40,6 @@ export async function main(options = {}) {
         await showMainMenu();
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err ?? '');
-        if (message.includes('SIGINT') || message.includes('User force closed')) {
-            console.log();
-            console.log(chalk.dim(t().common.goodbye));
-            process.exit(0);
-        }
-        else {
-            console.error('Error occurred:', message || err);
-            process.exit(1);
-        }
+        handleGracefulExit(err);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbtca/prompt",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -21,7 +21,7 @@
     "dev": "tsx src/index.ts",
     "dev:watch": "tsx watch src/index.ts",
     "build": "tsc",
-    "postbuild": "mkdir -p dist/logo dist/i18n/locales && cp src/logo/logo.txt dist/logo/ && cp src/logo/ascii-logo.txt dist/logo/ && cp src/i18n/locales/*.json dist/i18n/locales/",
+    "postbuild": "node scripts/copy-assets.js",
     "clean": "rm -rf dist",
     "prebuild": "npm run clean",
     "prepublishOnly": "npm run build",
@@ -38,21 +38,20 @@
     "interactive"
   ],
   "dependencies": {
-    "@clack/prompts": "^1.0.1",
-    "axios": "^1.6.2",
-    "chalk": "^5.4.1",
+    "@clack/prompts": "^1.2.0",
+    "chalk": "^5.6.2",
     "gradient-string": "^3.0.0",
-    "ical.js": "^2.0.1",
-    "marked": "^11.1.0",
+    "ical.js": "^2.2.1",
+    "marked": "^15.0.12",
     "marked-terminal": "^7.0.0",
-    "open": "^10.1.2"
+    "open": "^11.0.0"
   },
   "devDependencies": {
     "@types/gradient-string": "^1.1.6",
     "@types/marked-terminal": "^3.1.3",
-    "@types/node": "^20.11.0",
-    "tsx": "^4.7.0",
-    "typescript": "^5.3.3"
+    "@types/node": "^22.19.17",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
   },
   "engines": {
     "node": ">=20.12.0"