cvc-tui 0.4.4 → 0.4.7

package/dist/lib/terminalSetup.js

@@ -0,0 +1,321 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const DEFAULT_FILE_OPS = { copyFile, mkdir, readFile, writeFile };
+const COPY_SEQUENCE = '\u001b[99;13u';
+const MULTILINE_SEQUENCE = '\\\r\n';
+const TERMINAL_META = {
+    vscode: { appName: 'Code', label: 'VS Code' },
+    cursor: { appName: 'Cursor', label: 'Cursor' },
+    windsurf: { appName: 'Windsurf', label: 'Windsurf' }
+};
+const MAC_COPY_BINDING = {
+    key: 'cmd+c',
+    command: 'workbench.action.terminal.sendSequence',
+    when: 'terminalFocus && terminalTextSelected',
+    args: { text: COPY_SEQUENCE }
+};
+const BASE_BINDINGS = [
+    {
+        key: 'shift+enter',
+        command: 'workbench.action.terminal.sendSequence',
+        when: 'terminalFocus',
+        args: { text: MULTILINE_SEQUENCE }
+    },
+    {
+        key: 'ctrl+enter',
+        command: 'workbench.action.terminal.sendSequence',
+        when: 'terminalFocus',
+        args: { text: MULTILINE_SEQUENCE }
+    },
+    {
+        key: 'cmd+enter',
+        command: 'workbench.action.terminal.sendSequence',
+        when: 'terminalFocus',
+        args: { text: MULTILINE_SEQUENCE }
+    },
+    {
+        key: 'cmd+z',
+        command: 'workbench.action.terminal.sendSequence',
+        when: 'terminalFocus',
+        args: { text: '\u001b[122;9u' }
+    },
+    {
+        key: 'shift+cmd+z',
+        command: 'workbench.action.terminal.sendSequence',
+        when: 'terminalFocus',
+        args: { text: '\u001b[122;10u' }
+    }
+];
+const targetBindings = (platform) => platform === 'darwin' ? [MAC_COPY_BINDING, ...BASE_BINDINGS] : BASE_BINDINGS;
+export function detectVSCodeLikeTerminal(env = process.env) {
+    const askpass = env['VSCODE_GIT_ASKPASS_MAIN']?.toLowerCase() ?? '';
+    if (env['CURSOR_TRACE_ID'] || askpass.includes('cursor')) {
+        return 'cursor';
+    }
+    if (askpass.includes('windsurf')) {
+        return 'windsurf';
+    }
+    if (env['TERM_PROGRAM'] === 'vscode' || env['VSCODE_GIT_IPC_HANDLE']) {
+        return 'vscode';
+    }
+    return null;
+}
+/**
+ * Strip JSONC features (// line comments, /* block comments *\/, trailing commas)
+ * so the result is valid JSON parseable by JSON.parse().
+ * Handles comments inside strings correctly (preserves them).
+ */
+export function stripJsonComments(content) {
+    let result = '';
+    let i = 0;
+    const len = content.length;
+    while (i < len) {
+        const ch = content[i];
+        // String literal — copy as-is, including any comment-like chars inside
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < len) {
+                if (content[j] === '\\') {
+                    j += 2; // skip escaped char
+                }
+                else if (content[j] === '"') {
+                    j++;
+                    break;
+                }
+                else {
+                    j++;
+                }
+            }
+            result += content.slice(i, j);
+            i = j;
+            continue;
+        }
+        // Line comment
+        if (ch === '/' && content[i + 1] === '/') {
+            const eol = content.indexOf('\n', i);
+            i = eol === -1 ? len : eol;
+            continue;
+        }
+        // Block comment
+        if (ch === '/' && content[i + 1] === '*') {
+            const end = content.indexOf('*/', i + 2);
+            i = end === -1 ? len : end + 2;
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    // Remove trailing commas before ] or }
+    return result.replace(/,(\s*[}\]])/g, '$1');
+}
+export function isRemoteShellSession(env) {
+    return Boolean(env['SSH_CONNECTION'] || env['SSH_TTY'] || env['SSH_CLIENT']);
+}
+export function getVSCodeStyleConfigDir(appName, platform = process.platform, env = process.env, homeDir = homedir()) {
+    if (platform === 'darwin') {
+        return join(homeDir, 'Library', 'Application Support', appName, 'User');
+    }
+    if (platform === 'win32') {
+        return env['APPDATA'] ? join(env['APPDATA'], appName, 'User') : null;
+    }
+    return join(homeDir, '.config', appName, 'User');
+}
+function isKeybinding(value) {
+    return typeof value === 'object' && value !== null;
+}
+function sameBinding(a, b) {
+    return a.key === b.key && a.command === b.command && a.when === b.when && a.args?.text === b.args?.text;
+}
+const WHEN_TOKEN_RE = /!?[A-Za-z_][\w.]*/g;
+function parseWhenRequirements(when) {
+    const required = new Set();
+    const forbidden = new Set();
+    for (const [token] of when.matchAll(WHEN_TOKEN_RE)) {
+        if (token.startsWith('!')) {
+            forbidden.add(token.slice(1));
+        }
+        else {
+            required.add(token);
+        }
+    }
+    return { forbidden, required };
+}
+function requirementsContradict(a, b) {
+    for (const token of a.required) {
+        if (b.forbidden.has(token)) {
+            return true;
+        }
+    }
+    for (const token of b.required) {
+        if (a.forbidden.has(token)) {
+            return true;
+        }
+    }
+    return false;
+}
+function whensOverlap(a, b) {
+    if (a === b) {
+        return true;
+    }
+    // Empty when = global, overlaps every context.
+    if (!a || !b) {
+        return true;
+    }
+    const left = parseWhenRequirements(a);
+    const right = parseWhenRequirements(b);
+    if (requirementsContradict(left, right)) {
+        return false;
+    }
+    // This intentionally avoids a full VS Code when-clause parser. If two
+    // same-key bindings share a positive context token and don't explicitly
+    // contradict each other, they can fire together in that context.
+    for (const token of left.required) {
+        if (right.required.has(token)) {
+            return true;
+        }
+    }
+    return false;
+}
+// VS Code allows multiple bindings on the same key as long as their `when`
+// clauses don't overlap. We flag a conflict when the contexts overlap but
+// the bindings differ — e.g. existing `terminalFocus` cmd+c overlaps with
+// our `terminalFocus && terminalTextSelected`, so the existing binding
+// would shadow ours when text isn't selected.
+function bindingsConflict(existing, target) {
+    if (existing.key !== target.key) {
+        return false;
+    }
+    if (!whensOverlap(existing.when ?? '', target.when ?? '')) {
+        return false;
+    }
+    return !sameBinding(existing, target);
+}
+async function backupFile(filePath, ops) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    await ops.copyFile(filePath, `${filePath}.backup.${stamp}`);
+}
+export async function configureTerminalKeybindings(terminal, options) {
+    const env = options?.env ?? process.env;
+    const platform = options?.platform ?? process.platform;
+    const homeDir = options?.homeDir ?? homedir();
+    const ops = { ...DEFAULT_FILE_OPS, ...(options?.fileOps ?? {}) };
+    const meta = TERMINAL_META[terminal];
+    if (isRemoteShellSession(env)) {
+        return {
+            success: false,
+            message: `${meta.label} terminal setup must be run on the local machine, not inside an SSH session.`
+        };
+    }
+    const configDir = getVSCodeStyleConfigDir(meta.appName, platform, env, homeDir);
+    if (!configDir) {
+        return {
+            success: false,
+            message: `Could not determine ${meta.label} settings path on this platform.`
+        };
+    }
+    const keybindingsFile = join(configDir, 'keybindings.json');
+    try {
+        await ops.mkdir(configDir, { recursive: true });
+        let keybindings = [];
+        let hasExistingFile = false;
+        try {
+            const content = await ops.readFile(keybindingsFile, 'utf8');
+            hasExistingFile = true;
+            const parsed = JSON.parse(stripJsonComments(content));
+            if (!Array.isArray(parsed)) {
+                return {
+                    success: false,
+                    message: `${meta.label} keybindings.json is not a JSON array: ${keybindingsFile}`
+                };
+            }
+            keybindings = parsed;
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code !== 'ENOENT') {
+                return {
+                    success: false,
+                    message: `Failed to read ${meta.label} keybindings: ${error}`
+                };
+            }
+        }
+        const targets = targetBindings(platform);
+        const conflicts = targets.filter(target => keybindings.some(existing => isKeybinding(existing) && bindingsConflict(existing, target)));
+        if (conflicts.length) {
+            return {
+                success: false,
+                message: `Existing terminal keybindings would conflict in ${keybindingsFile}: ` + conflicts.map(c => c.key).join(', ')
+            };
+        }
+        let added = 0;
+        for (const target of targets.slice().reverse()) {
+            const exists = keybindings.some(existing => isKeybinding(existing) && sameBinding(existing, target));
+            if (!exists) {
+                keybindings.unshift(target);
+                added += 1;
+            }
+        }
+        if (!added) {
+            return {
+                success: true,
+                message: `${meta.label} terminal keybindings already configured.`
+            };
+        }
+        if (hasExistingFile) {
+            await backupFile(keybindingsFile, ops);
+        }
+        await ops.writeFile(keybindingsFile, `${JSON.stringify(keybindings, null, 2)}\n`, 'utf8');
+        return {
+            success: true,
+            requiresRestart: true,
+            message: `Added ${added} ${meta.label} terminal keybinding${added === 1 ? '' : 's'} in ${keybindingsFile}`
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to configure ${meta.label} terminal shortcuts: ${error}`
+        };
+    }
+}
+export async function configureDetectedTerminalKeybindings(options) {
+    const detected = detectVSCodeLikeTerminal(options?.env ?? process.env);
+    if (!detected) {
+        return {
+            success: false,
+            message: 'No supported IDE terminal detected. Supported: VS Code, Cursor, Windsurf.'
+        };
+    }
+    return configureTerminalKeybindings(detected, options);
+}
+export async function shouldPromptForTerminalSetup(options) {
+    const env = options?.env ?? process.env;
+    const detected = detectVSCodeLikeTerminal(env);
+    if (!detected || isRemoteShellSession(env)) {
+        return false;
+    }
+    const platform = options?.platform ?? process.platform;
+    const homeDir = options?.homeDir ?? homedir();
+    const ops = { ...DEFAULT_FILE_OPS, ...(options?.fileOps ?? {}) };
+    const meta = TERMINAL_META[detected];
+    const configDir = getVSCodeStyleConfigDir(meta.appName, platform, env, homeDir);
+    if (!configDir) {
+        return false;
+    }
+    try {
+        const content = await ops.readFile(join(configDir, 'keybindings.json'), 'utf8');
+        const parsed = JSON.parse(stripJsonComments(content));
+        if (!Array.isArray(parsed)) {
+            return true;
+        }
+        return targetBindings(platform).some(target => !parsed.some(existing => isKeybinding(existing) && sameBinding(existing, target)));
+    }
+    catch {
+        return true;
+    }
+}

package/dist/lib/text.js

@@ -0,0 +1,203 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { HISTORY_RENDER_MAX_CHARS, HISTORY_RENDER_MAX_LINES, LIVE_RENDER_MAX_CHARS, LIVE_RENDER_MAX_LINES, THINKING_COT_MAX } from '../config/limits.js';
+import { VERBS } from '../content/verbs.js';
+const ESC = String.fromCharCode(27);
+const ANSI_RE = new RegExp(`${ESC}\\[[0-9;]*m`, 'g');
+const WS_RE = /\s+/g;
+export const stripAnsi = (s) => s.replace(ANSI_RE, '');
+export const hasAnsi = (s) => s.includes(`${ESC}[`) || s.includes(`${ESC}]`);
+const renderEstimateLine = (line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('|')) {
+        return trimmed
+            .split('|')
+            .filter(Boolean)
+            .map(cell => cell.trim())
+            .join('  ');
+    }
+    return line
+        .replace(/!\[(.*?)\]\(([^)\s]+)\)/g, '[image: $1]')
+        .replace(/\[(.+?)\]\((https?:\/\/[^\s)]+)\)/g, '$1')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/\*\*(.+?)\*\*/g, '$1')
+        .replace(/(?<!\w)__(.+?)__(?!\w)/g, '$1')
+        .replace(/\*(.+?)\*/g, '$1')
+        .replace(/(?<!\w)_(.+?)_(?!\w)/g, '$1')
+        .replace(/~~(.+?)~~/g, '$1')
+        .replace(/==(.+?)==/g, '$1')
+        .replace(/\[\^([^\]]+)\]/g, '[$1]')
+        .replace(/^#{1,6}\s+/, '')
+        .replace(/^\s*[-*+]\s+\[( |x|X)\]\s+/, (_m, checked) => `• [${checked.toLowerCase() === 'x' ? 'x' : ' '}] `)
+        .replace(/^\s*[-*+]\s+/, '• ')
+        .replace(/^\s*(\d+)\.\s+/, '$1. ')
+        .replace(/^\s*(?:>\s*)+/, '│ ');
+};
+export const compactPreview = (s, max) => {
+    const one = s.replace(WS_RE, ' ').trim();
+    return !one ? '' : one.length > max ? one.slice(0, max - 1) + '…' : one;
+};
+export const estimateTokensRough = (text) => (!text ? 0 : (text.length + 3) >> 2);
+export const edgePreview = (s, head = 16, tail = 28) => {
+    const one = s.replace(WS_RE, ' ').trim().replace(/\]\]/g, '] ]');
+    return !one
+        ? ''
+        : one.length <= head + tail + 4
+            ? one
+            : `${one.slice(0, head).trimEnd()}.. ${one.slice(-tail).trimStart()}`;
+};
+export const pasteTokenLabel = (text, lineCount) => {
+    const preview = edgePreview(text);
+    if (!preview) {
+        return `[[ [${fmtK(lineCount)} lines] ]]`;
+    }
+    const [head = preview, tail = ''] = preview.split('.. ', 2);
+    return tail
+        ? `[[ ${head.trimEnd()}.. [${fmtK(lineCount)} lines] .. ${tail.trimStart()} ]]`
+        : `[[ ${preview} [${fmtK(lineCount)} lines] ]]`;
+};
+const THINKING_STATUS_RE = new RegExp(`^(?:${VERBS.join('|')})\\.{0,3}$`, 'i');
+const THINKING_STATUS_CHUNK_RE = new RegExp(`[^A-Za-z\n]+\\s*(?:${VERBS.join('|')})\\.{0,3}\\s*`, 'giu');
+export const cleanThinkingText = (reasoning) => reasoning
+    .split('\n')
+    .map(line => line.replace(THINKING_STATUS_CHUNK_RE, '').trim())
+    .filter(line => line && !THINKING_STATUS_RE.test(line.replace(/\.\.\.$/, '').trim()))
+    .join('\n')
+    .replace(/([^\n])(?=\*\*[^*\n][^\n]*?\*\*)/g, '$1\n\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+export const thinkingPreview = (reasoning, mode, max = THINKING_COT_MAX) => {
+    const raw = cleanThinkingText(reasoning);
+    return !raw || mode === 'collapsed' ? '' : mode === 'full' ? raw : compactPreview(raw.replace(WS_RE, ' '), max);
+};
+export const boundedLiveRenderText = (text, { maxChars = LIVE_RENDER_MAX_CHARS, maxLines = LIVE_RENDER_MAX_LINES } = {}) => boundedRenderText(text, 'showing live tail', { maxChars, maxLines });
+export const boundedHistoryRenderText = (text, { maxChars = HISTORY_RENDER_MAX_CHARS, maxLines = HISTORY_RENDER_MAX_LINES } = {}) => boundedRenderText(text, 'showing tail', { maxChars, maxLines });
+const boundedRenderText = (text, labelPrefix, { maxChars, maxLines }) => {
+    if (text.length <= maxChars && text.split('\n', maxLines + 1).length <= maxLines) {
+        return text;
+    }
+    let start = 0;
+    let idx = text.length;
+    for (let seen = 0; seen < maxLines && idx > 0; seen++) {
+        idx = text.lastIndexOf('\n', idx - 1);
+        start = idx < 0 ? 0 : idx + 1;
+        if (idx < 0) {
+            break;
+        }
+    }
+    const lineStart = start;
+    start = Math.max(lineStart, text.length - maxChars);
+    if (start > lineStart) {
+        const nextBreak = text.indexOf('\n', start);
+        if (nextBreak >= 0 && nextBreak < text.length - 1) {
+            start = nextBreak + 1;
+        }
+    }
+    const tail = text.slice(start).trimStart();
+    const omittedLines = countNewlines(text, start);
+    const omittedChars = Math.max(0, text.length - tail.length);
+    const label = omittedLines > 0
+        ? `[${labelPrefix}; omitted ${fmtK(omittedLines)} lines / ${fmtK(omittedChars)} chars]\n`
+        : `[${labelPrefix}; omitted ${fmtK(omittedChars)} chars]\n`;
+    return `${label}${tail}`;
+};
+const countNewlines = (text, end) => {
+    let count = 0;
+    for (let i = 0; i < end; i++) {
+        if (text.charCodeAt(i) === 10) {
+            count++;
+        }
+    }
+    return count;
+};
+export const stripTrailingPasteNewlines = (text) => (/[^\n]/.test(text) ? text.replace(/\n+$/, '') : text);
+export const toolTrailLabel = (name) => name
+    .split('_')
+    .filter(Boolean)
+    .map(p => p[0].toUpperCase() + p.slice(1))
+    .join(' ') || name;
+export const formatToolCall = (name, context = '') => {
+    const label = toolTrailLabel(name);
+    const preview = compactPreview(context, 64);
+    return preview ? `${label}("${preview}")` : label;
+};
+export const buildToolTrailLine = (name, context, error, note, duration) => {
+    const detail = compactPreview(note ?? '', 72);
+    const took = duration !== undefined ? ` (${duration.toFixed(1)}s)` : '';
+    return `${formatToolCall(name, context)}${took}${detail ? ` :: ${detail}` : ''} ${error ? '✗' : '✓'}`;
+};
+export const isToolTrailResultLine = (line) => line.endsWith(' ✓') || line.endsWith(' ✗');
+export const parseToolTrailResultLine = (line) => {
+    if (!isToolTrailResultLine(line)) {
+        return null;
+    }
+    const mark = line.endsWith(' ✗') ? '✗' : '✓';
+    const body = line.slice(0, -2);
+    const [call, detail] = body.split(' :: ', 2);
+    if (detail != null) {
+        return { call, detail, mark };
+    }
+    const legacy = body.indexOf(': ');
+    if (legacy > 0) {
+        return { call: body.slice(0, legacy), detail: body.slice(legacy + 2), mark };
+    }
+    return { call: body, detail: '', mark };
+};
+export const splitToolDuration = (call) => {
+    const match = call.match(/^(.*?)( \(\d+(?:\.\d)?s\))$/);
+    return match ? { label: match[1], duration: match[2] } : { label: call, duration: '' };
+};
+export const isTransientTrailLine = (line) => line.startsWith('drafting ') || line === 'analyzing tool output…';
+export const sameToolTrailGroup = (label, entry) => entry === `${label} ✓` ||
+    entry === `${label} ✗` ||
+    entry.startsWith(`${label}(`) ||
+    entry.startsWith(`${label} ::`) ||
+    entry.startsWith(`${label}:`);
+export const lastCotTrailIndex = (trail) => {
+    for (let i = trail.length - 1; i >= 0; i--) {
+        if (!isToolTrailResultLine(trail[i])) {
+            return i;
+        }
+    }
+    return -1;
+};
+export const estimateRows = (text, w, compact = false) => {
+    let fence = null;
+    let rows = 0;
+    for (const raw of text.split('\n')) {
+        const line = stripAnsi(raw);
+        const maybeFence = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
+        if (maybeFence) {
+            const marker = maybeFence[1];
+            const lang = maybeFence[2].trim();
+            if (!fence) {
+                fence = { char: marker[0], len: marker.length };
+                if (lang) {
+                    rows += Math.ceil((`─ ${lang}`.length || 1) / w);
+                }
+            }
+            else if (marker[0] === fence.char && marker.length >= fence.len) {
+                fence = null;
+            }
+            continue;
+        }
+        const inCode = Boolean(fence);
+        const trimmed = line.trim();
+        if (!inCode && trimmed.startsWith('|') && /^[|\s:-]+$/.test(trimmed)) {
+            continue;
+        }
+        const rendered = inCode ? line : renderEstimateLine(line);
+        if (compact && !rendered.trim()) {
+            continue;
+        }
+        rows += Math.ceil((rendered.length || 1) / w);
+    }
+    return Math.max(1, rows);
+};
+export const flat = (r) => Object.values(r).flat();
+const COMPACT_NUMBER = new Intl.NumberFormat('en-US', { maximumFractionDigits: 1, notation: 'compact' });
+export const fmtK = (n) => COMPACT_NUMBER.format(n).replace(/[KMBT]$/, s => s.toLowerCase());
+export const pick = (a) => a[Math.floor(Math.random() * a.length)];
+export const isPasteBackedText = (text) => /\[\[paste:\d+(?:[^\n]*?)\]\]|\[paste #\d+ (?:attached|excerpt)(?:[^\n]*?)\]/.test(text);

package/dist/lib/text.test.js

@@ -0,0 +1,18 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { describe, expect, it } from 'vitest';
+import { stripTrailingPasteNewlines } from './text.js';
+describe('stripTrailingPasteNewlines', () => {
+    it('removes trailing newline runs from pasted text', () => {
+        expect(stripTrailingPasteNewlines('alpha\n')).toBe('alpha');
+        expect(stripTrailingPasteNewlines('alpha\nbeta\n\n')).toBe('alpha\nbeta');
+    });
+    it('preserves interior newlines', () => {
+        expect(stripTrailingPasteNewlines('alpha\nbeta\ngamma')).toBe('alpha\nbeta\ngamma');
+    });
+    it('preserves newline-only pastes', () => {
+        expect(stripTrailingPasteNewlines('\n\n')).toBe('\n\n');
+    });
+});

package/dist/lib/todo.js

@@ -0,0 +1,2 @@
+export const todoGlyph = (status) => status === 'completed' ? '[x]' : status === 'cancelled' ? '[-]' : status === 'in_progress' ? '[>]' : '[ ]';
+export const todoTone = (status) => status === 'in_progress' ? 'active' : status === 'pending' ? 'body' : 'dim';

package/dist/lib/todo.test.js

@@ -0,0 +1,22 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { describe, expect, it } from 'vitest';
+import { todoGlyph, todoTone } from './todo.js';
+describe('todoGlyph', () => {
+    it('uses fixed-width ASCII markers so the active row does not render wide or emoji-like', () => {
+        expect(todoGlyph('completed')).toBe('[x]');
+        expect(todoGlyph('in_progress')).toBe('[>]');
+        expect(todoGlyph('pending')).toBe('[ ]');
+        expect(todoGlyph('cancelled')).toBe('[-]');
+    });
+});
+describe('todoTone', () => {
+    it('keeps todo status rows neutral instead of red/green', () => {
+        expect(todoTone('completed')).toBe('dim');
+        expect(todoTone('cancelled')).toBe('dim');
+        expect(todoTone('pending')).toBe('body');
+        expect(todoTone('in_progress')).toBe('active');
+    });
+});

package/dist/lib/viewportStore.js

@@ -0,0 +1,82 @@
+import { useCallback, useMemo, useSyncExternalStore } from 'react';
+const EMPTY = {
+    atBottom: true,
+    bottom: 0,
+    pending: 0,
+    scrollHeight: 0,
+    top: 0,
+    viewportHeight: 0
+};
+const EMPTY_SCROLLBAR = {
+    scrollHeight: 0,
+    top: 0,
+    viewportHeight: 0
+};
+export function getViewportSnapshot(s) {
+    if (!s) {
+        return EMPTY;
+    }
+    const pending = s.getPendingDelta();
+    const top = Math.max(0, s.getScrollTop() + pending);
+    const viewportHeight = Math.max(0, s.getViewportHeight());
+    const cachedScrollHeight = Math.max(viewportHeight, s.getScrollHeight());
+    let scrollHeight = cachedScrollHeight;
+    const bottom = top + viewportHeight;
+    let atBottom = s.isSticky() || bottom >= scrollHeight - 2;
+    if (!atBottom) {
+        scrollHeight = Math.max(viewportHeight, s.getFreshScrollHeight?.() ?? cachedScrollHeight);
+        atBottom = s.isSticky() || bottom >= scrollHeight - 2;
+    }
+    return {
+        atBottom,
+        bottom,
+        pending,
+        scrollHeight,
+        top,
+        viewportHeight
+    };
+}
+export function viewportSnapshotKey(v) {
+    return `${v.atBottom ? 1 : 0}:${Math.ceil(v.top / 8) * 8}:${v.viewportHeight}:${Math.ceil(v.scrollHeight / 8) * 8}:${v.pending}`;
+}
+export function getScrollbarSnapshot(s) {
+    if (!s) {
+        return EMPTY_SCROLLBAR;
+    }
+    const viewportHeight = Math.max(0, s.getViewportHeight());
+    const scrollHeight = Math.max(viewportHeight, s.getScrollHeight());
+    const maxTop = Math.max(0, scrollHeight - viewportHeight);
+    return {
+        scrollHeight,
+        top: Math.max(0, Math.min(maxTop, s.getScrollTop())),
+        viewportHeight
+    };
+}
+export function scrollbarSnapshotKey(v) {
+    return `${v.top}:${v.viewportHeight}:${v.scrollHeight}`;
+}
+export function useViewportSnapshot(scrollRef) {
+    const key = useSyncExternalStore(useCallback((cb) => scrollRef.current?.subscribe(cb) ?? (() => { }), [scrollRef]), () => viewportSnapshotKey(getViewportSnapshot(scrollRef.current)), () => viewportSnapshotKey(EMPTY));
+    return useMemo(() => {
+        const [atBottom = '1', top = '0', viewportHeight = '0', scrollHeight = '0', pending = '0'] = key.split(':');
+        return {
+            atBottom: atBottom === '1',
+            bottom: Number(top) + Number(viewportHeight),
+            pending: Number(pending),
+            scrollHeight: Number(scrollHeight),
+            top: Number(top),
+            viewportHeight: Number(viewportHeight)
+        };
+    }, [key]);
+}
+export function useScrollbarSnapshot(scrollRef) {
+    const key = useSyncExternalStore(useCallback((cb) => scrollRef.current?.subscribe(cb) ?? (() => { }), [scrollRef]), () => scrollbarSnapshotKey(getScrollbarSnapshot(scrollRef.current)), () => scrollbarSnapshotKey(EMPTY_SCROLLBAR));
+    return useMemo(() => {
+        const [top = '0', viewportHeight = '0', scrollHeight = '0'] = key.split(':');
+        return {
+            scrollHeight: Number(scrollHeight),
+            top: Number(top),
+            viewportHeight: Number(viewportHeight)
+        };
+    }, [key]);
+}