@nbtca/prompt 1.4.1 → 1.5.0

package/dist/core/text.js

@@ -1,101 +1,182 @@
-/** Codepoints that occupy zero terminal columns: combining modifiers that
- * merge into the glyph immediately before them, rather than rendering as
- * their own character (zero-width joiner, variation selectors). Emoji
- * sequences like a ZWJ family emoji or "❤️" (heart + VS-16) render as one
- * glyph — counting the modifier itself would overcount by a full column. */
+const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+const MARK_RE = /^\p{Mark}$/u;
+const EMOJI_PRESENTATION_RE = /\p{Emoji_Presentation}/u;
+const REGIONAL_INDICATOR_RE = /\p{Regional_Indicator}/u;
+function graphemes(value) {
+    return Array.from(GRAPHEME_SEGMENTER.segment(value), ({ segment }) => segment);
+}
 function isZeroWidth(cp) {
-    return cp === 0x200D // zero-width joiner
-        || cp === 0xFE0E // variation selector-15 (text presentation)
-        || cp === 0xFE0F; // variation selector-16 (emoji presentation)
+    return (cp === 0x200d || // zero-width joiner
+        cp === 0xfe0e || // variation selector-15 (text presentation)
+        cp === 0xfe0f); // variation selector-16 (emoji presentation)
 }
-/** Width of a single Unicode character: 2 for CJK/fullwidth/emoji, 1 otherwise. */
-function charWidth(ch) {
+function codePointWidth(ch) {
     const cp = ch.codePointAt(0) ?? 0;
-    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) ||
-        // Emoji block (Misc Symbols & Pictographs, Emoticons, Transport, Chess
-        // Symbols, Supplemental Symbols & Pictographs, Extended-A). Real
-        // terminals render these as double-width glyphs; undercounting even one
-        // emoji is enough to push a line one column past the terminal width and
-        // trigger an unwanted auto-wrap — this is a real bug that was found: an
-        // emoji-titled event line loading in scrolled the app's header out of
-        // view because of exactly this miscount.
-        (cp >= 0x1F300 && cp <= 0x1FAFF)) ? 2 : 1;
-}
-/** Strip ANSI escape sequences from a string. */
-// eslint-disable-next-line no-control-regex
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
+    if (isZeroWidth(cp) || MARK_RE.test(ch) || cp < 0x20 || (cp >= 0x7f && cp <= 0x9f))
+        return 0;
+    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) ||
+        (cp >= 0x1f300 && cp <= 0x1faff)
+        ? 2
+        : 1;
+}
+function graphemeWidth(grapheme) {
+    if (grapheme.includes('\ufe0f') ||
+        grapheme.includes('\u20e3') ||
+        EMOJI_PRESENTATION_RE.test(grapheme) ||
+        REGIONAL_INDICATOR_RE.test(grapheme)) {
+        return 2;
+    }
+    let width = 0;
+    for (const ch of grapheme)
+        width = Math.max(width, codePointWidth(ch));
+    return width;
+}
+const TERMINAL_ESCAPE_RE = /(?:\u001B\]|\u009D)[\s\S]*?(?:\u0007|\u001B\\|\u009C|$)|(?:\u001B[P_X^]|[\u0090\u0098\u009E\u009F])[\s\S]*?(?:\u001B\\|\u009C|$)|(?:\u001B\[|\u009B)[0-?]*[ -/]*[@-~]|\u001B[ -/]*[@-~]/g;
+const SGR_RE = /^(?:\u001B\[|\u009B)[0-9;]*m$/;
+const OSC8_RE = /^(?:\u001B\]|\u009D)8;[^;]*;([\s\S]*?)(?:\u0007|\u001B\\|\u009C)$/;
+const OSC8_CLOSE = '\u001B]8;;\u0007';
 export function stripAnsi(str) {
-    return str.replace(ANSI_RE, '');
+    return str.replace(TERMINAL_ESCAPE_RE, '');
+}
+const CONTROL_RE = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
+export function sanitizeTerminalText(str) {
+    return str.replace(/\r\n?/g, '\n').replace(TERMINAL_ESCAPE_RE, '').replace(CONTROL_RE, '');
+}
+export function sanitizeTerminalLine(str) {
+    return sanitizeTerminalText(str).replace(/\s+/gu, ' ').trim();
 }
-/** Total visual width of a string (CJK/emoji count as 2, zero-width
- * modifiers count as 0, ANSI codes ignored). */
 export function visualWidth(str) {
     const plain = stripAnsi(str);
     let w = 0;
-    for (const ch of plain) {
-        const cp = ch.codePointAt(0) ?? 0;
-        if (isZeroWidth(cp))
-            continue;
-        w += charWidth(ch);
-    }
+    for (const grapheme of graphemes(plain))
+        w += graphemeWidth(grapheme);
     return w;
 }
-/** Pad string to target visual width with trailing spaces. */
 export function padEndV(str, width) {
     const pad = width - visualWidth(str);
     return pad > 0 ? str + ' '.repeat(pad) : str;
 }
-/** Truncate to visual width limit, appending '...' if cut. */
 export function truncate(str, maxWidth) {
     if (visualWidth(str) <= maxWidth)
         return str;
+    if (maxWidth <= 0)
+        return '';
+    const marker = maxWidth >= 3 ? '...' : '.'.repeat(maxWidth);
+    const available = maxWidth - visualWidth(marker);
     let w = 0;
-    let i = 0;
-    for (const ch of str) {
-        const cp = ch.codePointAt(0) ?? 0;
-        const cw = isZeroWidth(cp) ? 0 : charWidth(ch);
-        if (w + cw > maxWidth - 3)
+    let value = '';
+    for (const grapheme of graphemes(str)) {
+        const cw = graphemeWidth(grapheme);
+        if (w + cw > available)
             break;
         w += cw;
-        i += ch.length;
+        value += grapheme;
     }
-    return str.slice(0, i) + '...';
+    return value + marker;
+}
+export function truncateStart(str, maxWidth, marker = '...') {
+    if (visualWidth(str) <= maxWidth)
+        return str;
+    if (maxWidth <= 0)
+        return '';
+    let fittedMarker = '';
+    let markerWidth = 0;
+    for (const segment of graphemes(marker)) {
+        const segmentWidth = graphemeWidth(segment);
+        if (markerWidth + segmentWidth > maxWidth)
+            break;
+        fittedMarker += segment;
+        markerWidth += segmentWidth;
+    }
+    const available = Math.max(0, maxWidth - visualWidth(fittedMarker));
+    const segments = graphemes(str);
+    let value = '';
+    let width = 0;
+    for (let index = segments.length - 1; index >= 0; index -= 1) {
+        const segment = segments[index];
+        if (segment === undefined)
+            continue;
+        const segmentWidth = graphemeWidth(segment);
+        if (width + segmentWidth > available)
+            break;
+        value = segment + value;
+        width += segmentWidth;
+    }
+    return fittedMarker + value;
+}
+function osc8State(sequence) {
+    const match = OSC8_RE.exec(sequence);
+    if (!match)
+        return undefined;
+    return match[1] ? sequence : null;
 }
 function tokenizeForWrapping(str) {
     const tokens = [];
-    let index = 0;
-    while (index < str.length) {
-        const ansi = /^\x1b\[[0-9;]*m/.exec(str.slice(index));
-        if (ansi) {
-            tokens.push({ raw: ansi[0], width: 0, whitespace: false, sgr: true });
-            index += ansi[0].length;
-            continue;
+    const pushText = (value) => {
+        for (const grapheme of graphemes(value)) {
+            tokens.push({
+                raw: grapheme,
+                width: graphemeWidth(grapheme),
+                whitespace: /\s/u.test(grapheme),
+                sgr: false,
+            });
         }
-        const cp = str.codePointAt(index) ?? 0;
-        const raw = String.fromCodePoint(cp);
+    };
+    let index = 0;
+    for (const match of str.matchAll(TERMINAL_ESCAPE_RE)) {
+        const start = match.index;
+        pushText(str.slice(index, start));
+        const raw = match[0];
+        const osc8 = osc8State(raw);
         tokens.push({
             raw,
-            width: isZeroWidth(cp) ? 0 : charWidth(raw),
-            whitespace: /\s/u.test(raw),
-            sgr: false,
+            width: 0,
+            whitespace: false,
+            sgr: SGR_RE.test(raw),
+            ...(osc8 === undefined ? {} : { osc8 }),
         });
-        index += raw.length;
+        index = start + match[0].length;
     }
+    pushText(str.slice(index));
     return tokens;
 }
+export function clipAnsiToVisualWidth(str, maxWidth) {
+    const limit = Math.max(0, Math.floor(maxWidth));
+    if (visualWidth(str) <= limit)
+        return str;
+    const tokens = tokenizeForWrapping(str);
+    const output = [];
+    let width = 0;
+    let activeOsc8 = null;
+    for (const token of tokens) {
+        if (token.sgr || token.width === 0) {
+            output.push(token.raw);
+            if (token.osc8 !== undefined)
+                activeOsc8 = token.osc8;
+            continue;
+        }
+        if (width + token.width > limit)
+            break;
+        output.push(token.raw);
+        width += token.width;
+    }
+    if (activeOsc8)
+        output.push(OSC8_CLOSE);
+    return output.join('');
+}
 function advanceSgr(active, tokens, start, end) {
     let next = active;
     for (let index = start; index < end; index += 1) {
@@ -112,12 +193,24 @@ function advanceSgr(active, tokens, start, end) {
     }
     return next;
 }
-function renderWrappedSegment(tokens, start, end, prefix) {
-    const body = tokens.slice(start, end).map((token) => token.raw).join('');
-    const styled = prefix + body;
-    return prefix || tokens.slice(start, end).some((token) => token.sgr)
-        ? `${styled}\x1b[0m`
-        : styled;
+function advanceOsc8(active, tokens, start, end) {
+    let next = active;
+    for (let index = start; index < end; index += 1) {
+        const token = tokens[index];
+        if (token?.osc8 !== undefined)
+            next = token.osc8;
+    }
+    return next;
+}
+function renderWrappedSegment(tokens, start, end, activeSgr, activeOsc8) {
+    const body = tokens
+        .slice(start, end)
+        .map((token) => token.raw)
+        .join('');
+    const styled = `${activeOsc8 ?? ''}${activeSgr}${body}`;
+    const withReset = activeSgr || tokens.slice(start, end).some((token) => token.sgr) ? `${styled}\x1b[0m` : styled;
+    const osc8AtEnd = advanceOsc8(activeOsc8, tokens, start, end);
+    return osc8AtEnd ? `${withReset}${OSC8_CLOSE}` : withReset;
 }
 export function wrapAnsiToVisualWidth(str, maxWidth) {
     const widthLimit = Math.max(1, Math.floor(maxWidth));
@@ -126,6 +219,7 @@ export function wrapAnsiToVisualWidth(str, maxWidth) {
     const tokens = tokenizeForWrapping(str);
     const lines = [];
     let activeSgr = '';
+    let activeOsc8 = null;
     let start = 0;
     while (start < tokens.length) {
         let width = 0;
@@ -149,7 +243,7 @@ export function wrapAnsiToVisualWidth(str, maxWidth) {
             index += 1;
         }
         if (index >= tokens.length) {
-            lines.push(renderWrappedSegment(tokens, start, tokens.length, activeSgr));
+            lines.push(renderWrappedSegment(tokens, start, tokens.length, activeSgr, activeOsc8));
             break;
         }
         const overflow = tokens[index];
@@ -166,9 +260,22 @@ export function wrapAnsiToVisualWidth(str, maxWidth) {
             end = Math.max(index, start + 1);
             next = end;
         }
-        lines.push(renderWrappedSegment(tokens, start, end, activeSgr));
+        lines.push(renderWrappedSegment(tokens, start, end, activeSgr, activeOsc8));
         activeSgr = advanceSgr(activeSgr, tokens, start, next);
+        activeOsc8 = advanceOsc8(activeOsc8, tokens, start, next);
         start = next;
     }
     return lines.length > 0 ? lines : [''];
 }
+export function wrapAnsiWithIndent(str, maxWidth, preferredIndent = '') {
+    const width = Number.isFinite(maxWidth)
+        ? Math.max(1, Math.floor(maxWidth))
+        : Number.POSITIVE_INFINITY;
+    const indentWidth = visualWidth(preferredIndent);
+    const contentWidth = visualWidth(str);
+    const indent = indentWidth >= width || (contentWidth > width - indentWidth && contentWidth <= width)
+        ? ''
+        : preferredIndent;
+    const availableWidth = Math.max(1, width - visualWidth(indent));
+    return wrapAnsiToVisualWidth(str, availableWidth).map((line) => `${indent}${line}`);
+}

package/dist/core/theme.js

@@ -1,21 +1,11 @@
 import chalk from 'chalk';
 import gradient from 'gradient-string';
 import { pickIcon } from './icons.js';
-// The one gradient the brand uses anywhere it appears -- the startup logo,
-// and (in text form) the persistent header wordmark. Defined once here so
-// both stay the same three stops instead of drifting apart.
 export const brandGradient = gradient([
     { color: '#124689', pos: 0 },
     { color: '#0ea5e9', pos: 0.55 },
     { color: '#06b6d4', pos: 1 },
 ]);
-/** The brand wordmark treatment: bold text painted in `brandGradient`,
- * falling back to plain text under NO_COLOR (gradient-string doesn't
- * auto-respect it the way chalk's own colors do). Currently used by the
- * header's persistent "nbtca" mark (`app/chrome.ts`) -- named here, not
- * left as a one-off local helper, so any future chrome element that wants
- * "the brand gradient, as a wordmark" has a single place to reuse instead
- * of re-deriving the NO_COLOR/bold/gradient combination again. */
 export function brandMark(s) {
     if (process.env['NO_COLOR'])
         return s;
@@ -49,11 +39,6 @@ export const glyph = {
     dot: () => pickIcon('●', '*'),
     updown: () => pickIcon('↑↓', 'up/down'),
     enter: () => pickIcon('⏎', 'enter'),
-    // Two-level "how full" bar cell (Home's day-progress, Schedule's
-    // term-progress) — a single source of truth so every such bar in the
-    // app reads as the same visual language. Not the same vocabulary as
-    // calendar-heatmap's 5-level intensity scale, which is a deliberately
-    // finer-grained density visualization, not a binary fill/empty bar.
     barFilled: () => pickIcon('█', '#'),
     barEmpty: () => pickIcon('░', '-'),
 };
@@ -65,19 +50,6 @@ export const type = {
     label: (s) => chalk.white(s),
     body: (s) => s,
     hint: (s) => chalk.dim(s),
-    /** The one thing on this screen your eye should land on: the app's own
-     * name, the tab you're on, the row a menu's cursor sits on, the class
-     * that's happening right now. `heading` marks a section as structure;
-     * `active` marks a single point as attention — never both on the same
-     * element, and never more than one or two `active` uses per screen, or
-     * the signal stops meaning anything. Brand color (#0ea5e9) precisely
-     * because there is exactly one brand-worthy thing to say on each of
-     * these screens, and this is where it belongs. */
     active: (s) => chalk.bold(c.brand(s)),
-    /** The grid cursor's own visual signal: a solid brand-colored background
-     * block, deliberately distinct from `active` (bold text on the default
-     * background) so "this is today" and "this is where your cursor is" never
-     * share one visual language, even when the cursor lands on today's own
-     * column. */
     cursor: (s) => chalk.bgHex('#0ea5e9').black(s),
 };

package/dist/core/transitions.js

@@ -1,15 +1,15 @@
 import { clearScreen } from './ui.js';
 import { typeReveal } from './motion.js';
 import { glyph, type, space } from './theme.js';
-import { screenWidth } from './components/screen.js';
 import { pickIcon } from './icons.js';
 export function breadcrumb(label) {
     return `nbtca ${pickIcon('›', '>')} ${label}`;
 }
 export function buildScreenHeaderLines(crumb) {
+    const width = Math.min(process.stdout.columns || 80, 64);
     return [
         space.indent + type.heading(crumb),
-        space.indent + type.hint(glyph.rule().repeat(screenWidth())),
+        space.indent + type.hint(glyph.rule().repeat(width)),
         '',
     ];
 }

package/dist/core/ui.js

@@ -1,46 +1,31 @@
-/**
- * Minimalist UI component library
- * Delegates to self-rendered widgets for terminal output
- */
 import { success, error, warning, info } from './components/messages.js';
 import { startSpinner } from './components/spinner.js';
 import chalk from 'chalk';
-import { pickIcon } from './icons.js';
 import { t } from '../i18n/index.js';
+import { sanitizeTerminalLine } from './text.js';
 export { success, error, warning, info };
-/**
- * Display divider line
- */
-export function printDivider() {
-    const terminalWidth = process.stdout.columns || 80;
-    const dividerChar = pickIcon('─', '-');
-    console.log(chalk.dim(dividerChar.repeat(Math.min(terminalWidth, 80))));
-}
-/**
- * Clear screen
- */
 export function clearScreen() {
     if (process.stdout.isTTY) {
         console.clear();
     }
 }
-/**
- * Print empty lines
- */
-export function printNewLine(count = 1) {
-    for (let i = 0; i < count; i++) {
-        console.log();
-    }
-}
-/**
- * Create and start a real async spinner.
- * Caller is responsible for calling .stop(msg) or .stop(msg, 1) on error.
- */
 export function createSpinner(msg) {
     return startSpinner(msg);
 }
+function errorMessage(errorValue) {
+    if (errorValue instanceof Error)
+        return errorValue.message;
+    if (typeof errorValue === 'string')
+        return errorValue;
+    if (typeof errorValue === 'number' ||
+        typeof errorValue === 'boolean' ||
+        typeof errorValue === 'bigint') {
+        return String(errorValue);
+    }
+    return '';
+}
 export function handleGracefulExit(err) {
-    const message = err instanceof Error ? err.message : String(err ?? '');
+    const message = sanitizeTerminalLine(errorMessage(err));
     if (message.includes('SIGINT') || message.includes('User force closed')) {
         console.log();
         console.log(chalk.dim(t().common.goodbye));
@@ -50,7 +35,7 @@ export function handleGracefulExit(err) {
         console.error(message);
     }
     else {
-        console.error('Error occurred:', err);
+        console.error('An unexpected error occurred.');
     }
     process.exit(1);
 }

package/dist/core/vim-keys.js

@@ -1,17 +1,10 @@
-/**
- * Vim keybindings support
- * Intercepts raw data events and replaces vim keys with terminal escape sequences
- * before readline processes them. This avoids patching the keypress layer which
- * breaks in Node.js v25+ (emitKeys generator crash).
- */
-// Maps single-byte vim keys to terminal escape sequences (ranger-style hjkl)
 const VIM_TO_SEQ = {
-    j: Buffer.from('\u001b[B'), // down arrow
-    k: Buffer.from('\u001b[A'), // up arrow
-    l: Buffer.from('\r'), // enter/confirm (ranger: open/enter)
-    g: Buffer.from('\u001b[H'), // home (first item)
-    G: Buffer.from('\u001b[F'), // end (last item)
-    q: Buffer.from('\u0003'), // quit
+    j: Buffer.from('\u001b[B'),
+    k: Buffer.from('\u001b[A'),
+    l: Buffer.from('\r'),
+    g: Buffer.from('\u001b[H'),
+    G: Buffer.from('\u001b[F'),
+    q: Buffer.from('\u0003'),
 };
 let vimActive = true;
 export function setVimKeysActive(active) {
@@ -22,15 +15,16 @@ export function enableVimKeys() {
     if (!stdin.isTTY)
         return;
     const originalEmit = stdin.emit.bind(stdin);
-    stdin.emit = function (event, ...args) {
+    const translatedEmit = (event, ...args) => {
         if (event === 'data' && vimActive) {
             const chunk = args[0];
             if (Buffer.isBuffer(chunk) && chunk.length === 1) {
-                const seq = VIM_TO_SEQ[String.fromCharCode(chunk[0])];
+                const seq = VIM_TO_SEQ[String.fromCharCode(chunk.readUInt8(0))];
                 if (seq)
                     return originalEmit('data', seq);
             }
         }
         return originalEmit(event, ...args);
     };
+    stdin.emit = translatedEmit;
 }

package/dist/features/about.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { APP_INFO, URLS } from '../config/data.js';
+import { note } from '../core/components/note.js';
+import { pickIcon } from '../core/icons.js';
+import { padEndV } from '../core/text.js';
+import { t } from '../i18n/index.js';
+export function showAbout() {
+    const trans = t();
+    const row = (label, value) => `${chalk.dim(padEndV(label, 12))}${value}`;
+    const link = (label, url) => row(label, chalk.cyan(url));
+    const content = [
+        row(trans.about.project, APP_INFO.name),
+        row(trans.about.version, `v${APP_INFO.version}`),
+        row(trans.about.description, trans.about.descriptionText),
+        '',
+        link(trans.about.github, APP_INFO.repository),
+        link(trans.about.website, URLS.homepage),
+        link(trans.about.email, URLS.email),
+        '',
+        row(trans.about.license, `MIT  ${pickIcon('·', '|')}  ${trans.about.author}: m1ngsama`),
+    ].join('\n');
+    note(content, trans.about.title);
+}

package/dist/features/calendar-heatmap.js

@@ -1,12 +1,7 @@
-/**
- * Heatmap renderer for calendar activity.
- * GitHub-contributions-style grid: 7 weekday rows (Mon..Sun), week columns.
- */
 import chalk from 'chalk';
 import { pickIcon } from '../core/icons.js';
 import { space, type } from '../core/theme.js';
 import { t, getCurrentLanguage } from '../i18n/index.js';
-/** Parse a 'YYYY-MM-DD' date string into a UTC proxy Date (host-timezone-independent). */
 function parseBucketDate(date) {
     const parts = date.split('-').map(Number);
     const y = parts[0] ?? 0;
@@ -14,11 +9,9 @@ function parseBucketDate(date) {
     const d = parts[2] ?? 1;
     return new Date(Date.UTC(y, m - 1, d));
 }
-/** 0=Sun,1=Mon,...,6=Sat -> Mon-indexed 0..6 */
 function utcDayToMonIndex(utcDay) {
     return (utcDay + 6) % 7;
 }
-/** Map a count to a unicode intensity glyph (or ASCII fallback). */
 function countToGlyph(count) {
     if (count <= 0)
         return pickIcon('·', ' ');
@@ -30,46 +23,28 @@ function countToGlyph(count) {
         return pickIcon('▓', '-');
     return pickIcon('█', '=');
 }
-// A fixed 4-stop truecolor green ramp, not chalk's named green/greenBright --
-// those resolve to whatever the user's terminal theme defines for "green",
-// same problem the rest of the app's palette solved by specifying hex
-// directly (theme.ts's brand blue, brandGradient) instead of leaning on
-// ANSI color names. Kept muted/desaturated rather than a punchy grass
-// green so it sits quietly next to the app's own cool blue palette instead
-// of reading as a louder, disconnected accent.
 const HEATMAP_RAMP = ['#1b4332', '#2d6a4f', '#40916c', '#52b788'];
 const MAX_WEEK_COLUMNS = 53;
 const GRID_PREFIX_WIDTH = 6;
-/** Apply a green color ramp based on count. Identity when count is 0. */
 function applyColor(glyph, count, useColor) {
     if (!useColor || count <= 0)
         return glyph;
     const level = Math.min(count, HEATMAP_RAMP.length) - 1;
     return chalk.hex(HEATMAP_RAMP[level])(glyph);
 }
-/**
- * Render a GitHub-contributions-style heatmap grid.
- *
- * @param buckets  Dense daily buckets from nbtcal's .heatmap() call.
- * @param today    The "today" date (used to determine the end column).
- * @param options  Optional rendering options.
- */
 export function renderHeatmap(buckets, today, options) {
     const useColor = options?.color === true;
     const trans = t();
-    const cellWidth = options?.cols !== undefined
-        && options.cols < GRID_PREFIX_WIDTH + MAX_WEEK_COLUMNS * 2 ? 1 : 2;
+    const cellWidth = options?.cols !== undefined && options.cols < GRID_PREFIX_WIDTH + MAX_WEEK_COLUMNS * 2 ? 1 : 2;
     const availableColumns = options?.cols === undefined
         ? MAX_WEEK_COLUMNS
         : Math.floor((options.cols - GRID_PREFIX_WIDTH) / cellWidth);
     const numCols = Math.max(1, Math.min(MAX_WEEK_COLUMNS, availableColumns));
-    // Build a lookup map: 'YYYY-MM-DD' -> count
     const countByDate = new Map();
     for (const b of buckets) {
         countByDate.set(b.date, b.count);
     }
     const todayProxy = new Date(Date.UTC(today.getFullYear(), today.getMonth(), today.getDate()));
-    // Find the Monday that starts the week containing today
     const todayMonIndex = utcDayToMonIndex(todayProxy.getUTCDay());
     const gridEndMs = todayProxy.getTime() + (6 - todayMonIndex) * 86400000; // Sunday of today's week
     const gridStartMs = gridEndMs - (numCols * 7 - 1) * 86400000;
@@ -96,7 +71,11 @@ export function renderHeatmap(buckets, today, options) {
         columns.push(column);
     }
     const weekdayLabel = space.indent; // matches the grid rows' "Mo " prefix width
-    const monthFmt = new Intl.DateTimeFormat('en-US', { month: 'short', timeZone: 'UTC' });
+    const language = getCurrentLanguage();
+    const monthFmt = new Intl.DateTimeFormat(language === 'zh' ? 'zh-CN' : 'en-US', {
+        month: 'short',
+        timeZone: 'UTC',
+    });
     const cellsWidth = numCols * cellWidth;
     const monthChars = new Array(cellsWidth).fill(' ');
     let prevMonth = -1;
@@ -122,24 +101,22 @@ export function renderHeatmap(buckets, today, options) {
         }
     }
     const monthLabelLine = space.indent + weekdayLabel + monthChars.join('');
-    // Weekday labels (Mon/Wed/Fri only, index 0/2/4 in Mon-indexed scheme)
-    const lang = getCurrentLanguage();
-    const weekdayNames = lang === 'zh'
-        ? ['一', '  ', '三', '  ', '五', '  ', '  ']
-        : ['Mo', '  ', 'We', '  ', 'Fr', '  ', '  '];
-    // Build output lines
+    const weekdayNames = [
+        trans.timetable.weekdayMon.slice(0, 2),
+        '  ',
+        trans.timetable.weekdayWed.slice(0, 2),
+        '  ',
+        trans.timetable.weekdayFri.slice(0, 2),
+        '  ',
+        '  ',
+    ];
     const lines = [];
-    // Title line — same space.indent + type.heading treatment every other
-    // section heading in the app uses (this one was bare, so it sat flush
-    // against the terminal edge instead of matching the app's 3-space margin).
     lines.push(space.indent + type.heading(trans.calendar.heatmap.title));
     lines.push('');
-    // Month labels line
     lines.push(monthLabelLine);
-    // Grid rows (7 rows: Mon..Sun)
     for (let row = 0; row < 7; row++) {
         const wdLabel = weekdayNames[row] ?? '  ';
-        const cells = columns.map(col => {
+        const cells = columns.map((col) => {
             const cell = col[row];
             if (cell === null || cell === undefined)
                 return ' ';
@@ -148,7 +125,6 @@ export function renderHeatmap(buckets, today, options) {
         });
         lines.push(`${space.indent}${wdLabel} ${cells.join(cellWidth === 2 ? ' ' : '')}`);
     }
-    // Legend line
     const legendGlyphs = [
         pickIcon('·', ' '),
         pickIcon('░', '.'),