@nbtca/prompt 1.3.2 → 1.4.1

package/dist/core/motion.js

@@ -0,0 +1,86 @@
+import { getCapabilities } from './capabilities.js';
+import { ansi } from './canvas.js';
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function typeReveal(lines, opts = {}) {
+    const write = opts.write ?? ((s) => { process.stdout.write(s); });
+    const reduced = opts.reducedMotion ?? getCapabilities().reducedMotion;
+    if (reduced) {
+        write(lines.join('\n') + '\n');
+        return;
+    }
+    const stepMs = opts.stepMs ?? 45;
+    for (const line of lines) {
+        write(line + '\n');
+        await sleep(stepMs);
+    }
+}
+const BRAILLE_BASE = 0x2800;
+function brailleMask(ch) {
+    const code = ch.codePointAt(0) ?? 0;
+    return code >= BRAILLE_BASE && code <= BRAILLE_BASE + 0xff ? code - BRAILLE_BASE : -1;
+}
+/**
+ * Reveals a block of braille dot-matrix art by assembling it dot-by-dot in
+ * scattered order, rather than popping it in line by line -- a reveal that
+ * matches what the art actually is (an addressable grid of dots) instead of
+ * reusing the plain-text typewriter effect built for prose. Non-braille
+ * characters (spaces, stray ASCII) pass through unchanged on every frame.
+ */
+export async function materializeBraille(art, paint, opts = {}) {
+    const write = opts.write ?? ((s) => { process.stdout.write(s); });
+    const reduced = opts.reducedMotion ?? getCapabilities().reducedMotion;
+    const lines = art.split('\n');
+    const charGrid = lines.map((line) => [...line]);
+    const maskGrid = charGrid.map((row) => row.map(brailleMask));
+    if (reduced || !maskGrid.some((row) => row.some((m) => m > 0))) {
+        write(paint(art) + '\n');
+        return;
+    }
+    const dots = [];
+    maskGrid.forEach((row, r) => row.forEach((mask, c) => {
+        if (mask <= 0)
+            return;
+        for (let bit = 0; bit < 8; bit++)
+            if (mask & (1 << bit))
+                dots.push([r, c, bit]);
+    }));
+    const rand = opts.random ?? Math.random;
+    for (let i = dots.length - 1; i > 0; i--) {
+        const j = Math.floor(rand() * (i + 1));
+        const a = dots[i], b = dots[j];
+        if (a && b) {
+            dots[i] = b;
+            dots[j] = a;
+        }
+    }
+    const acc = maskGrid.map((row) => row.map(() => 0));
+    const renderFrame = () => charGrid.map((row, r) => row.map((original, c) => {
+        const mask = maskGrid[r]?.[c] ?? -1;
+        if (mask <= 0)
+            return original;
+        return String.fromCodePoint(BRAILLE_BASE + (acc[r]?.[c] ?? 0));
+    }).join('')).join('\n');
+    const frameCount = Math.max(1, opts.frames ?? 12);
+    const frameMs = opts.frameMs ?? 35;
+    let shown = 0;
+    for (let f = 1; f <= frameCount; f++) {
+        const target = Math.round((dots.length * f) / frameCount);
+        while (shown < target) {
+            const d = dots[shown];
+            if (d) {
+                const [r, c, bit] = d;
+                const row = acc[r];
+                if (row)
+                    row[c] = (row[c] ?? 0) | (1 << bit);
+            }
+            shown++;
+        }
+        write(paint(renderFrame()) + '\n');
+        if (f < frameCount) {
+            await sleep(frameMs);
+            write(ansi.cursorUp(lines.length) + ansi.cursorToCol0 + ansi.eraseDown);
+        }
+    }
+}

package/dist/core/text.js

@@ -1,4 +1,14 @@
-/** Width of a single Unicode character: 2 for CJK/fullwidth, 1 otherwise. */
+/** 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. */
+function isZeroWidth(cp) {
+    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) {
     const cp = ch.codePointAt(0) ?? 0;
     return ((cp >= 0x1100 && cp <= 0x115F) ||
@@ -14,7 +24,15 @@ function charWidth(ch) {
         (cp >= 0x20000 && cp <= 0x2A6DF) ||
         (cp >= 0x2A700 && cp <= 0x2CEAF) ||
         (cp >= 0x2CEB0 && cp <= 0x2EBEF) ||
-        (cp >= 0x30000 && cp <= 0x323AF)) ? 2 : 1;
+        (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
@@ -22,12 +40,17 @@ const ANSI_RE = /\x1b\[[0-9;]*m/g;
 export function stripAnsi(str) {
     return str.replace(ANSI_RE, '');
 }
-/** Total visual width of a string (CJK characters count as 2, ANSI codes ignored). */
+/** 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)
+    for (const ch of plain) {
+        const cp = ch.codePointAt(0) ?? 0;
+        if (isZeroWidth(cp))
+            continue;
         w += charWidth(ch);
+    }
     return w;
 }
 /** Pad string to target visual width with trailing spaces. */
@@ -42,7 +65,8 @@ export function truncate(str, maxWidth) {
     let w = 0;
     let i = 0;
     for (const ch of str) {
-        const cw = charWidth(ch);
+        const cp = ch.codePointAt(0) ?? 0;
+        const cw = isZeroWidth(cp) ? 0 : charWidth(ch);
         if (w + cw > maxWidth - 3)
             break;
         w += cw;
@@ -50,3 +74,101 @@ export function truncate(str, maxWidth) {
     }
     return str.slice(0, i) + '...';
 }
+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 cp = str.codePointAt(index) ?? 0;
+        const raw = String.fromCodePoint(cp);
+        tokens.push({
+            raw,
+            width: isZeroWidth(cp) ? 0 : charWidth(raw),
+            whitespace: /\s/u.test(raw),
+            sgr: false,
+        });
+        index += raw.length;
+    }
+    return tokens;
+}
+function advanceSgr(active, tokens, start, end) {
+    let next = active;
+    for (let index = start; index < end; index += 1) {
+        const token = tokens[index];
+        if (!token?.sgr)
+            continue;
+        const params = token.raw.slice(2, -1).split(';');
+        if (params.includes('0') || params[0] === '') {
+            next = params.length === 1 ? '' : token.raw;
+        }
+        else {
+            next += token.raw;
+        }
+    }
+    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;
+}
+export function wrapAnsiToVisualWidth(str, maxWidth) {
+    const widthLimit = Math.max(1, Math.floor(maxWidth));
+    if (!Number.isFinite(maxWidth) || visualWidth(str) <= widthLimit)
+        return [str];
+    const tokens = tokenizeForWrapping(str);
+    const lines = [];
+    let activeSgr = '';
+    let start = 0;
+    while (start < tokens.length) {
+        let width = 0;
+        let hasVisible = false;
+        let lastWhitespace = -1;
+        let index = start;
+        while (index < tokens.length) {
+            const token = tokens[index];
+            if (!token)
+                break;
+            if (token.sgr || token.width === 0) {
+                index += 1;
+                continue;
+            }
+            if (width + token.width > widthLimit && hasVisible)
+                break;
+            width += token.width;
+            hasVisible = true;
+            if (token.whitespace)
+                lastWhitespace = index;
+            index += 1;
+        }
+        if (index >= tokens.length) {
+            lines.push(renderWrappedSegment(tokens, start, tokens.length, activeSgr));
+            break;
+        }
+        const overflow = tokens[index];
+        let end = index;
+        let next = index;
+        if (overflow?.whitespace) {
+            next = index + 1;
+        }
+        else if (lastWhitespace >= start) {
+            end = lastWhitespace;
+            next = lastWhitespace + 1;
+        }
+        if (end === start) {
+            end = Math.max(index, start + 1);
+            next = end;
+        }
+        lines.push(renderWrappedSegment(tokens, start, end, activeSgr));
+        activeSgr = advanceSgr(activeSgr, tokens, start, next);
+        start = next;
+    }
+    return lines.length > 0 ? lines : [''];
+}

package/dist/core/theme.js

@@ -1,4 +1,26 @@
 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;
+    return chalk.bold(brandGradient(s));
+}
 export const c = {
     brand: (s) => chalk.hex('#0ea5e9')(s),
     accent: (s) => chalk.cyan(s),
@@ -20,3 +42,42 @@ export const c = {
         return chalk.red(s);
     },
 };
+export const glyph = {
+    cursor: () => pickIcon('→', '>'),
+    rule: () => pickIcon('─', '-'),
+    bullet: () => pickIcon('·', '.'),
+    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('░', '-'),
+};
+export const space = {
+    indent: '   ',
+};
+export const type = {
+    heading: (s) => chalk.bold.white(s),
+    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

@@ -0,0 +1,19 @@
+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) {
+    return [
+        space.indent + type.heading(crumb),
+        space.indent + type.hint(glyph.rule().repeat(screenWidth())),
+        '',
+    ];
+}
+export async function enterScreen(crumb) {
+    clearScreen();
+    await typeReveal(buildScreenHeaderLines(crumb));
+}

package/dist/core/ui.js

@@ -1,35 +1,13 @@
 /**
  * Minimalist UI component library
- * Delegates to @clack/prompts for modern terminal output
+ * Delegates to self-rendered widgets for terminal output
  */
-import { log, spinner as clackSpinner } from '@clack/prompts';
+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';
-/**
- * Display success message
- */
-export function success(msg) {
-    log.success(msg);
-}
-/**
- * Display error message
- */
-export function error(msg) {
-    log.error(msg);
-}
-/**
- * Display info message
- */
-export function info(msg) {
-    log.info(msg);
-}
-/**
- * Display warning message
- */
-export function warning(msg) {
-    log.warn(msg);
-}
+export { success, error, warning, info };
 /**
  * Display divider line
  */
@@ -59,9 +37,7 @@ export function printNewLine(count = 1) {
  * Caller is responsible for calling .stop(msg) or .stop(msg, 1) on error.
  */
 export function createSpinner(msg) {
-    const s = clackSpinner();
-    s.start(msg);
-    return s;
+    return startSpinner(msg);
 }
 export function handleGracefulExit(err) {
     const message = err instanceof Error ? err.message : String(err ?? '');

package/dist/features/calendar-heatmap.js

@@ -4,6 +4,7 @@
  */
 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) {
@@ -29,17 +30,22 @@ 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;
-    if (count === 1)
-        return chalk.green(glyph);
-    if (count === 2)
-        return chalk.green(glyph);
-    if (count === 3)
-        return chalk.greenBright(glyph);
-    return chalk.bold.greenBright(glyph);
+    const level = Math.min(count, HEATMAP_RAMP.length) - 1;
+    return chalk.hex(HEATMAP_RAMP[level])(glyph);
 }
 /**
  * Render a GitHub-contributions-style heatmap grid.
@@ -51,21 +57,21 @@ function applyColor(glyph, count, useColor) {
 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 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);
     }
-    // Determine the grid window.
-    // The grid ends at "today" (aligned to Mon-start week column).
-    // The grid starts 365 days before today.
     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
-    // Grid start: 52 full weeks back from the start of today's week, plus today's partial week
-    // Total columns = 53 weeks
-    const numCols = 53;
     const gridStartMs = gridEndMs - (numCols * 7 - 1) * 86400000;
     const gridStart = new Date(gridStartMs);
     const columns = [];
@@ -89,15 +95,9 @@ export function renderHeatmap(buckets, today, options) {
         }
         columns.push(column);
     }
-    // Month labels row. Labels are 3-letter English abbreviations (universal and
-    // single-width, so alignment holds in any language). Each grid column occupies
-    // 2 terminal cells (glyph + joining space); we write each month's label into a
-    // character buffer starting at the column where that month begins, letting it
-    // overflow rightward into the spacing of the following columns (months are
-    // ~4-5 columns apart, so labels never collide).
-    const weekdayLabel = '   '; // 3-char prefix, matches the grid rows' "Mo " prefix
+    const weekdayLabel = space.indent; // matches the grid rows' "Mo " prefix width
     const monthFmt = new Intl.DateTimeFormat('en-US', { month: 'short', timeZone: 'UTC' });
-    const cellsWidth = numCols * 2;
+    const cellsWidth = numCols * cellWidth;
     const monthChars = new Array(cellsWidth).fill(' ');
     let prevMonth = -1;
     for (let col = 0; col < numCols; col++) {
@@ -115,13 +115,13 @@ export function renderHeatmap(buckets, today, options) {
         if (month !== prevMonth) {
             prevMonth = month;
             const label = monthFmt.format(labelDate); // e.g. "Jun"
-            const start = col * 2;
+            const start = col * cellWidth;
             for (let i = 0; i < label.length && start + i < cellsWidth; i++) {
                 monthChars[start + i] = label[i] ?? ' ';
             }
         }
     }
-    const monthLabelLine = weekdayLabel + monthChars.join('');
+    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'
@@ -129,8 +129,10 @@ export function renderHeatmap(buckets, today, options) {
         : ['Mo', '  ', 'We', '  ', 'Fr', '  ', '  '];
     // Build output lines
     const lines = [];
-    // Title line
-    lines.push(trans.calendar.heatmap.title);
+    // 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);
@@ -144,7 +146,7 @@ export function renderHeatmap(buckets, today, options) {
             const glyph = countToGlyph(cell.count);
             return applyColor(glyph, cell.count, useColor);
         });
-        lines.push(`${wdLabel} ${cells.join(' ')}`);
+        lines.push(`${space.indent}${wdLabel} ${cells.join(cellWidth === 2 ? ' ' : '')}`);
     }
     // Legend line
     const legendGlyphs = [
@@ -164,6 +166,6 @@ export function renderHeatmap(buckets, today, options) {
         ]
         : legendGlyphs;
     lines.push('');
-    lines.push(`${trans.calendar.heatmap.legendLess} ${legendColored.join('')} ${trans.calendar.heatmap.legendMore}`);
+    lines.push(`${space.indent}${type.hint(trans.calendar.heatmap.legendLess)} ${legendColored.join('')} ${type.hint(trans.calendar.heatmap.legendMore)}`);
     return lines.join('\n');
 }

package/dist/features/calendar-query.js

@@ -0,0 +1,50 @@
+export function weekRange(now) {
+    const start = new Date(now);
+    start.setHours(0, 0, 0, 0);
+    const mondayOffset = (start.getDay() + 6) % 7; // days since Monday
+    start.setDate(start.getDate() - mondayOffset);
+    const end = new Date(start);
+    end.setDate(end.getDate() + 7);
+    return { start, end };
+}
+export function monthRange(now) {
+    const start = new Date(now.getFullYear(), now.getMonth(), 1, 0, 0, 0, 0);
+    const end = new Date(now.getFullYear(), now.getMonth() + 1, 1, 0, 0, 0, 0);
+    return { start, end };
+}
+export function filterEvents(events, query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return events;
+    return events.filter((e) => (e.title ?? '').toLowerCase().includes(q) ||
+        (e.location ?? '').toLowerCase().includes(q));
+}
+export function countdownParts(target, now) {
+    const ms = target.getTime() - now.getTime();
+    if (ms <= 0)
+        return { past: true, days: 0, hours: 0, minutes: 0 };
+    const totalMin = Math.floor(ms / 60000);
+    return {
+        past: false,
+        days: Math.floor(totalMin / 1440),
+        hours: Math.floor((totalMin % 1440) / 60),
+        minutes: totalMin % 60,
+    };
+}
+/** True once a countdown is close enough to call out visually (default: 15
+ * minutes or less). A `past` countdown is never urgent — there's nothing
+ * left to hurry for. */
+export function isCountdownUrgent(p, thresholdMinutes = 15) {
+    if (p.past)
+        return false;
+    const totalMinutes = p.days * 1440 + p.hours * 60 + p.minutes;
+    return totalMinutes <= thresholdMinutes;
+}
+export function buildExportFilename(event) {
+    const cleaned = (event.title ?? '')
+        .replace(/[^\p{L}\p{N}\-_ ]/gu, '')
+        .trim()
+        .replace(/\s+/g, '-')
+        .slice(0, 60);
+    return `${cleaned || 'event'}.ics`;
+}