@nbtca/prompt 1.0.23 → 1.0.25

package/dist/features/docs.js

@@ -2,17 +2,17 @@
  * 知识库终端查看模块
  * 获取并渲染Markdown文档
  */
-import axios from 'axios';
 import { marked } from 'marked';
 import TerminalRenderer from 'marked-terminal';
 import chalk from 'chalk';
 import open from 'open';
-import { select, isCancel, confirm } from '@clack/prompts';
+import { select, isCancel, confirm, text } from '@clack/prompts';
 import { error, warning, success, createSpinner } from '../core/ui.js';
 import { pickIcon } from '../core/icons.js';
 import { spawn, execFileSync } from 'child_process';
-import { URLS } from '../config/data.js';
-import { t } from '../i18n/index.js';
+import { APP_INFO, GITHUB_REPO, URLS } from '../config/data.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();
@@ -38,8 +38,27 @@ function commandExists(cmd) {
         return false;
     }
 }
-const TERMINAL_TYPE = detectTerminalType();
-const HAS_GLOW = commandExists('glow');
+let _terminalType = null;
+function getTerminalType() {
+    if (_terminalType === null)
+        _terminalType = detectTerminalType();
+    return _terminalType;
+}
+let _hasGlow = null;
+function hasGlow() {
+    if (_hasGlow === null)
+        _hasGlow = commandExists('glow');
+    return _hasGlow;
+}
+let _markedConfigured = false;
+function ensureMarkedConfigured() {
+    if (_markedConfigured)
+        return;
+    _markedConfigured = true;
+    marked.use({
+        renderer: new TerminalRenderer(getRendererOptions(getTerminalType()))
+    });
+}
 // ─── marked-terminal renderer ─────────────────────────────────────────────────
 function getRendererOptions(type) {
     // Cap at 80 columns — optimal prose reading width regardless of terminal size
@@ -82,10 +101,7 @@ function getRendererOptions(type) {
         }
     };
 }
-// @ts-ignore
-marked.setOptions({ renderer: new TerminalRenderer(getRendererOptions(TERMINAL_TYPE)) });
 // ─── GitHub data layer ────────────────────────────────────────────────────────
-const GITHUB_REPO = { owner: 'nbtca', repo: 'documents', branch: 'main' };
 const GITHUB_TOKEN = process.env['GITHUB_TOKEN'] || process.env['GH_TOKEN'];
 const SKIP_NAMES = new Set(['node_modules', 'package.json', 'pnpm-lock.yaml']);
 const DIR_CACHE_TTL_MS = 5 * 60 * 1000;
@@ -96,15 +112,13 @@ const fileCache = new Map();
 const renderCache = new Map();
 function getDocCategories() {
     const trans = t();
-    const withIcon = (unicodeIcon, asciiIcon, label) => `${pickIcon(unicodeIcon, asciiIcon)} ${label}`;
     return [
-        { name: withIcon('📖', '[DOC]', trans.docs.categoryTutorial), path: 'tutorial' },
-        { name: withIcon('🔧', '[LOG]', trans.docs.categoryRepairLogs), path: '维修日' },
-        { name: withIcon('🎉', '[EVT]', trans.docs.categoryEvents), path: '相关活动举办' },
-        { name: withIcon('📋', '[PROC]', trans.docs.categoryProcess), path: 'process' },
-        { name: withIcon('🛠', '[FIX]', trans.docs.categoryRepair), path: 'repair' },
-        { name: withIcon('📦', '[ARC]', trans.docs.categoryArchived), path: 'archived' },
-        { name: withIcon('📄', '[README]', trans.docs.categoryReadme), path: 'README.md' },
+        { 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 getFreshCacheValue(cache, key) {
@@ -122,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);
@@ -144,19 +170,36 @@ async function fetchGitHubDirectory(path = '', options = {}) {
     try {
         const headers = {
             'Accept': 'application/vnd.github.v3+json',
-            'User-Agent': 'NBTCA-CLI'
+            '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')))
             .map((item) => ({
             name: item.name,
             path: item.path,
-            type: item.type === 'dir' ? 'dir' : 'file',
+            type: (item.type === 'dir' ? 'dir' : 'file'),
             sha: item.sha
         }))
             .sort((a, b) => {
@@ -167,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) {
@@ -175,17 +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);
-        if (err.response?.status === 403) {
-            const rateLimitRemaining = err.response.headers['x-ratelimit-remaining'];
-            const rateLimitReset = err.response.headers['x-ratelimit-reset'];
-            if (rateLimitRemaining === '0') {
-                const resetDate = new Date(parseInt(rateLimitReset) * 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 = {}) {
@@ -197,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' } });
-        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) {
@@ -208,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 ─────────────────────────────────────────────────────────
@@ -219,7 +267,7 @@ const CONTAINER_ICONS_ASCII = {
 const CONTAINER_ICONS_UNICODE = {
     info: 'ℹ️', tip: '💡', warning: '⚠️', danger: '🚨', details: '▶️'
 };
-function cleanMarkdownContent(content, type) {
+function cleanMarkdownContent(content, type = getTerminalType()) {
     let c = content;
     // 1. YAML frontmatter
     c = c.replace(/^---\n[\s\S]*?\n---\n?/m, '');
@@ -259,9 +307,17 @@ function cleanMarkdownContent(content, type) {
     c = c.replace(/\n{3,}/g, '\n\n');
     return c.trim();
 }
-function extractDocTitle(content) {
-    const match = content.match(/^#\s+(.+)$/m);
-    return match?.[1]?.trim() ?? null;
+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) {
@@ -339,116 +395,134 @@ 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('');
-        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.gray(`${pickIcon('↑', '[..]')} ${trans.docs.upToParent}`) }] : []),
+            ...(currentPath ? [{ value: '__back__', label: chalk.dim(trans.docs.upToParent) }] : []),
             ...items.map(item => ({
                 value: item.path,
                 label: item.type === 'dir'
-                    ? chalk.cyan(`${pickIcon('📁', '[DIR]')} ${item.name}/`)
-                    : chalk.white(`${pickIcon('📄', '[MD]')} ${item.name}`),
-                hint: item.type === 'dir' ? 'dir' : '.md',
+                    ? chalk.cyan(`${item.name}/`)
+                    : item.name,
+                hint: item.type === 'dir' ? 'dir' : undefined,
             })),
-            { value: '__exit__', label: chalk.gray(`${pickIcon('✕', '[x]')} ${trans.docs.returnToMenu}`) },
+            { 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);
-        console.log(chalk.gray(`  ${trans.docs.errorHint}: ${err.message}`));
-        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 {
-        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, TERMINAL_TYPE);
-            const title = extractDocTitle(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 (HAS_GLOW) {
-            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: `${pickIcon('←', '[<]')} ${trans.docs.backToList}` },
-                { value: 'reread', label: `${pickIcon('↻', '[r]')} ${trans.docs.reread}` },
-                { value: 'browser', label: `${pickIcon('🌐', '[*]')} ${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);
-        console.log(chalk.gray(`  ${trans.docs.errorHint}: ${err.message}`));
-        const openBrowser = await confirm({ message: trans.docs.openBrowserPrompt });
-        if (!isCancel(openBrowser) && openBrowser) {
-            await openDocsInBrowser(filePath);
         }
     }
 }
@@ -469,6 +543,71 @@ export async function openDocsInBrowser(path) {
     }
     console.log();
 }
+// ─── 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();
+    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 res = await fetchGitHubDirectory(cat.path);
+            return { items: res.data, category: cat.name };
+        }));
+        for (const result of fetches) {
+            if (result.status !== 'fulfilled')
+                continue;
+            for (const item of result.value.items) {
+                const nameLC = item.name.toLowerCase();
+                if (nameLC.includes(keyword)) {
+                    results.push({ name: item.name, path: item.path, category: result.value.category });
+                }
+            }
+        }
+        // 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 {
+        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() {
     while (true) {
@@ -476,9 +615,10 @@ export async function showDocsMenu() {
         const categories = getDocCategories();
         const options = [
             ...categories.map(cat => ({ value: cat.path, label: cat.name })),
-            { value: 'refresh-cache', label: chalk.gray(`${pickIcon('♻️', '[r]')} ${trans.docs.refreshCache}`) },
-            { value: 'browser', label: chalk.gray(`${pickIcon('🌐', '[*]')} ${trans.docs.openBrowser}`) },
-            { value: 'back', label: chalk.gray(`${pickIcon('←', '[^]')} ${trans.docs.returnToMenu}`) },
+            { 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,
@@ -486,19 +626,18 @@ export async function showDocsMenu() {
         });
         if (isCancel(action) || action === 'back')
             return;
-        if (action === 'refresh-cache') {
+        if (action === 'search') {
+            await searchDocs();
+        }
+        else if (action === 'refresh-cache') {
             clearDocsCache();
             success(trans.docs.cacheCleared);
         }
         else if (action === 'browser') {
             await openDocsInBrowser();
         }
-        else if (action === 'README.md') {
-            await viewMarkdownFile('README.md');
-        }
         else {
             await browseDirectory(action);
         }
     }
 }
-//# sourceMappingURL=docs.js.map

package/dist/features/links.js

@@ -0,0 +1,37 @@
+/**
+ * Links — open NBTCA resources in browser
+ */
+import open from 'open';
+import chalk from 'chalk';
+import { select, isCancel } from '@clack/prompts';
+import { createSpinner } from '../core/ui.js';
+import { URLS } from '../config/data.js';
+import { t } from '../i18n/index.js';
+async function openUrl(url) {
+    const trans = t();
+    const s = createSpinner(trans.links.opening);
+    try {
+        await open(url);
+        s.stop(trans.links.opened);
+    }
+    catch {
+        s.error(trans.links.error);
+        console.log(chalk.dim(`  ${url}`));
+    }
+}
+export async function showLinksMenu() {
+    const trans = t();
+    const selected = await select({
+        message: trans.links.choose,
+        options: [
+            { value: URLS.homepage, label: trans.links.website },
+            { value: URLS.github, label: trans.links.github },
+            { value: URLS.roadmap, label: trans.links.roadmap },
+            { value: URLS.repair, label: trans.links.repair },
+            { value: '__back__', label: chalk.dim(trans.common.back) },
+        ],
+    });
+    if (isCancel(selected) || selected === '__back__')
+        return;
+    await openUrl(selected);
+}