@toddzheng024/dscode-bundle 0.7.12 → 0.7.13

package/vendor/tui/lib/render/usage.mjs

@@ -0,0 +1,336 @@
+/**
+ * Session usage for the /usage panel: the provider-reported token totals, the
+ * context pressure and composition, and the exact per-turn accounting, folded
+ * into the styled rows the panel draws.
+ *
+ * Every figure comes from the harness token meter. The four token buckets are
+ * disjoint, so the prompt side is never double counted; the composition block
+ * is a density estimate and is labelled as one.
+ *
+ * @module @deepseek-ai/dsh-tui/render/usage
+ */
+import { t } from '../i18n.mjs';
+import { lineSegment } from './lines.mjs';
+import { visibleColumns } from './markdown.mjs';
+import { formatTokens } from './status.mjs';
+import { truncateColumns } from './text.mjs';
+/** Prompt-side tokens the provider billed: uncached input plus both cache buckets. */
+export function billedInputTokens(totals) {
+    return totals.uncachedInputTokens + totals.cacheReadTokens + totals.cacheWriteTokens;
+}
+/** Prompt plus completion tokens over the whole log. */
+export function usageTotalTokens(totals) {
+    return billedInputTokens(totals) + totals.outputTokens;
+}
+/**
+ * Cache-hit share of billed prompt-side input.
+ * @param totals - cumulative provider-reported buckets.
+ * @returns percent rounded to one decimal place, or null when nothing was billed.
+ */
+export function usageCacheHitPercent(totals) {
+    const billed = billedInputTokens(totals);
+    return billed === 0 ? null : Math.round(totals.cacheReadTokens / billed * 1_000) / 10;
+}
+/**
+ * Split a durable log into COMPLETE turns. A turn still running has no
+ * `turn/end` yet, and an unfinished attempt has no exact accounting, so the
+ * trailing slice is dropped rather than guessed at.
+ * @param events - the whole durable log, in log order.
+ * @returns one slice per `turn/start`…`turn/end` span, oldest first.
+ */
+export function completedTurns(events) {
+    const slices = [];
+    let open;
+    for (const event of events) {
+        if (event.type === 'turn/start') {
+            open = { turn: event.data.turn, events: [event] };
+            continue;
+        }
+        if (open === undefined)
+            continue;
+        open.events.push(event);
+        if (event.type === 'turn/end') {
+            slices.push(open);
+            open = undefined;
+        }
+    }
+    return slices;
+}
+/**
+ * Exact usage for every completed turn that can be proven.
+ * @param events - the whole durable log, in log order.
+ * @param derive - the meter's per-turn fold, injected so this module stays pure.
+ * @returns one row per provable turn, oldest first; turns whose attempts did
+ *   not all report usage are omitted rather than estimated, and so is a turn
+ *   that billed nothing at all — an empty row is noise in a usage table.
+ */
+export function turnUsages(events, derive) {
+    const rows = [];
+    for (const slice of completedTurns(events)) {
+        const usage = derive(slice.events);
+        if (usage === undefined || usage.totalTokens === 0)
+            continue;
+        rows.push({ turn: slice.turn, usage, model: turnModel(slice, usage) });
+    }
+    return rows;
+}
+/** Pad to a column budget so labels line up across terminal widths. */
+function padColumns(text, columns) {
+    return text + ' '.repeat(Math.max(0, columns - visibleColumns(text)));
+}
+/** One `label` + `value` row of a summary block. */
+function pairLine(label, value, labelColumns, style = 'plain') {
+    const gap = ' '.repeat(Math.max(1, labelColumns - visibleColumns(label)));
+    return { segments: [lineSegment('  ' + label + gap, 'dim'), lineSegment(value, style)] };
+}
+/**
+ * Merge the per-turn rows by the model that billed them, biggest spender
+ * first. A turn lands in exactly one group — the group named by every model it
+ * used — so the sums stay additive and a mid-turn model switch never counts
+ * the same tokens twice. Each bucket is merged over the turns that reported
+ * it, and {@link ModelUsage.partial} records the ones that stayed silent.
+ * @param turns - provable per-turn rows, oldest first.
+ * @returns one row per model group.
+ */
+export function modelTotals(turns) {
+    const groups = new Map();
+    for (const row of turns) {
+        groups.set(row.model, [...(groups.get(row.model) ?? []), row]);
+    }
+    const merged = [];
+    for (const [model, rows] of groups) {
+        const partial = [];
+        // A bucket is summed over the turns that reported it. Refusing the whole
+        // group because ONE turn stayed silent would contradict the per-turn table
+        // right below, where those same turns show real cache reads; the floor is
+        // marked instead of thrown away.
+        const sum = (key) => {
+            const reported = rows.flatMap(row => row.usage[key] === undefined ? [] : [row.usage[key]]);
+            if (reported.length === 0)
+                return undefined;
+            if (reported.length < rows.length)
+                partial.push(key);
+            return reported.reduce((total, value) => total + value, 0);
+        };
+        const cacheReadTokens = sum('cacheReadTokens');
+        const cacheWriteTokens = sum('cacheWriteTokens');
+        const reasoningTokens = sum('reasoningTokens');
+        merged.push({
+            model,
+            turns: rows.length,
+            uncachedInputTokens: rows.reduce((sum, row) => sum + row.usage.uncachedInputTokens, 0),
+            outputTokens: rows.reduce((sum, row) => sum + row.usage.outputTokens, 0),
+            totalTokens: rows.reduce((sum, row) => sum + row.usage.totalTokens, 0),
+            cacheReadTokens,
+            cacheWriteTokens,
+            reasoningTokens,
+            partial,
+        });
+    }
+    // Biggest spender first; turns nothing could attribute stay at the bottom,
+    // because that row is a gap in the record rather than a model.
+    return merged.sort((left, right) => (left.model === '' ? 1 : right.model === '' ? -1 : right.totalTokens - left.totalTokens));
+}
+/** Cut one styled line to a column budget, keeping every style it fits. */
+function boundLine(line, width) {
+    const segments = [];
+    let left = width;
+    for (const segment of line.segments) {
+        if (left <= 0)
+            break;
+        const columns = visibleColumns(segment.text);
+        if (columns <= left) {
+            segments.push(segment);
+            left -= columns;
+            continue;
+        }
+        segments.push(lineSegment(truncateColumns(segment.text, left), segment.style));
+        left = 0;
+    }
+    return { segments };
+}
+/** A block heading. */
+function heading(text) {
+    return { segments: [lineSegment(text, 'accentBold')] };
+}
+/** A dim explanatory or empty-state row. */
+function note(text) {
+    return { segments: [lineSegment('  ' + text, 'dim')] };
+}
+/**
+ * Cache-hit share of one row's billed prompt side, or undefined when the row
+ * has no cache read to report. An unreported cache-write bucket counts as
+ * zero: the adapters that bill cache writes always report the bucket, so its
+ * absence means the route never tracked one — the same reading the status
+ * bar's own fold uses.
+ */
+function hitShare(row) {
+    if (row.cacheReadTokens === undefined)
+        return undefined;
+    const billed = row.uncachedInputTokens + row.cacheReadTokens + (row.cacheWriteTokens ?? 0);
+    if (billed === 0)
+        return undefined;
+    return Math.round(row.cacheReadTokens / billed * 1_000) / 10;
+}
+/** The token columns, in display order (shared by both tables). */
+/** True when the row's bucket is a floor rather than a complete figure. */
+function isPartial(row, key) {
+    return row.partial?.includes(key) === true;
+}
+const BUCKET_COLUMNS = [
+    { label: () => t('panel.usage.colTotal'), value: row => formatTokens(row.totalTokens), width: 9 },
+    { label: () => t('panel.usage.colUncached'), value: row => formatTokens(row.uncachedInputTokens), width: 9 },
+    { label: () => t('panel.usage.colCacheRead'), value: row => optionalTokens(row.cacheReadTokens, isPartial(row, 'cacheReadTokens')), width: 9 },
+    {
+        label: () => t('panel.usage.colCacheHit'),
+        value: row => percent(hitShare(row), isPartial(row, 'cacheReadTokens') || isPartial(row, 'cacheWriteTokens')),
+        width: 8,
+    },
+    { label: () => t('panel.usage.colCacheWrite'), value: row => optionalTokens(row.cacheWriteTokens, isPartial(row, 'cacheWriteTokens')), width: 9 },
+    { label: () => t('panel.usage.colOut'), value: row => formatTokens(row.outputTokens), width: 9 },
+    { label: () => t('panel.usage.colThink'), value: row => optionalTokens(row.reasoningTokens, isPartial(row, 'reasoningTokens')), width: 9 },
+];
+/** A percentage, or an em dash when the row cannot prove one; `+` for a floor. */
+function percent(value, partial = false) {
+    return value === undefined ? '—' : value + '%' + (partial ? '+' : '');
+}
+/**
+ * A bucket as a table cell: an em dash when nothing reported it, and a `+`
+ * when the figure counts only the turns of a group that did report it.
+ */
+function optionalTokens(value, partial = false) {
+    if (value === undefined)
+        return '—';
+    return formatTokens(value) + (partial ? '+' : '');
+}
+/** What an unattributed turn or group is called in the tables. */
+function modelLabel(model) {
+    return model === '' ? t('panel.usage.unknownModel') : model;
+}
+/**
+ * The model a turn's assistant messages came from: the one that produced most
+ * of them, with a tie naming every model involved. This is the fallback for
+ * turns whose meter `routes` were withheld, and it reads only what the log
+ * recorded — nothing is inferred from the current selection.
+ */
+function dominantModel(events) {
+    const counts = new Map();
+    for (const event of events) {
+        if (event.type !== 'assistant/message')
+            continue;
+        const source = event.data.message.source;
+        if (source.kind !== 'model' || source.model === '')
+            continue;
+        counts.set(source.model, (counts.get(source.model) ?? 0) + 1);
+    }
+    if (counts.size === 0)
+        return '';
+    const most = Math.max(...counts.values());
+    return [...counts.entries()]
+        .filter(([, count]) => count === most)
+        .map(([model]) => model)
+        .sort()
+        .join(' + ');
+}
+/** The model attribution for one turn: the meter's routes, else its messages. */
+export function turnModel(slice, usage) {
+    const routes = usage.routes ?? [];
+    if (routes.length > 0)
+        return routes.map(route => route.model).join(' + ');
+    return dominantModel(slice.events);
+}
+/**
+ * Render one table: a dim header plus one row per entry. The free-text cell
+ * (the model name) keeps a readable share of the width, so trailing numeric
+ * columns drop first on a narrow terminal instead of leaving an ellipsised
+ * model name — the name is what the reader came for.
+ * @param columns - the numeric columns, most important first.
+ * @param rows - one entry per line, already in display order.
+ * @param text - how to read the free-text cell of one entry.
+ * @param width - the column budget.
+ * @param textFirst - true puts the free-text cell before the numbers (the
+ *   model-group table); false appends it (the per-turn table).
+ * @returns the header row plus one row per entry.
+ */
+function table(columns, rows, text, width, textFirst) {
+    const budget = width - 2;
+    const minText = 14;
+    const kept = [];
+    let used = 0;
+    for (const column of columns) {
+        if (used + column.width > budget - minText - 1)
+            break;
+        kept.push(column);
+        used += column.width;
+    }
+    // Capped so a wide terminal does not stretch one column across the panel.
+    const textWidth = Math.min(24, Math.max(6, budget - used - 1));
+    const numbers = (row) => kept.map(column => padColumns(column.value(row), column.width)).join('');
+    const header = kept.map(column => padColumns(column.label(), column.width)).join('');
+    const headerText = textFirst
+        ? padColumns(t('panel.usage.colModel'), textWidth) + ' ' + header
+        : header + ' ' + t('panel.usage.colModel');
+    const lines = [
+        { segments: [lineSegment(truncateColumns('  ' + headerText, width), 'dim')] },
+    ];
+    for (const row of rows) {
+        const label = truncateColumns(text(row), textWidth);
+        lines.push({
+            segments: [lineSegment('  ' + (textFirst ? padColumns(label, textWidth) + ' ' + numbers(row) : numbers(row) + ' ' + label), 'plain')],
+        });
+    }
+    return lines;
+}
+/**
+ * Render the panel body.
+ * @param view - the projection totals plus the derived per-turn rows.
+ * @param columns - usable content columns inside the panel border.
+ * @returns bounded, styled rows ready to draw.
+ */
+export function usageLines(view, columns) {
+    const width = Math.max(8, Math.floor(columns));
+    const lines = [];
+    lines.push(heading(t('panel.usage.totals')));
+    const totals = view.totals;
+    if (totals === undefined) {
+        lines.push(note(t('panel.usage.unavailable')));
+    }
+    else {
+        const label = 12;
+        lines.push(pairLine(t('panel.usage.uncached'), formatTokens(totals.uncachedInputTokens), label));
+        lines.push(pairLine(t('panel.usage.cacheWrite'), formatTokens(totals.cacheWriteTokens), label));
+        lines.push(pairLine(t('panel.usage.cacheRead'), formatTokens(totals.cacheReadTokens), label));
+        lines.push(pairLine(t('panel.usage.output'), formatTokens(totals.outputTokens), label));
+        lines.push(pairLine(t('panel.usage.total'), formatTokens(usageTotalTokens(totals)), label, 'bold'));
+        const hit = usageCacheHitPercent(totals);
+        if (hit !== null)
+            lines.push(pairLine(t('panel.usage.cacheHit'), hit + '%', label));
+    }
+    lines.push({ segments: [] });
+    const models = modelTotals(view.turns);
+    lines.push(heading(models.length === 0 ? t('panel.usage.byModel') : `${t('panel.usage.byModel')} · ${models.length}`));
+    if (models.length === 0) {
+        lines.push(note(t('panel.usage.noTurns')));
+    }
+    else {
+        lines.push(...table([
+            { label: () => t('panel.usage.colTurns'), value: (row) => String(row.turns), width: 7 },
+            ...BUCKET_COLUMNS.map(column => ({ ...column, value: (row) => column.value(row) })),
+        ], models, row => modelLabel(row.model), width, true));
+        if (models.some(row => row.partial.length > 0))
+            lines.push(note(t('panel.usage.partialNote')));
+    }
+    lines.push({ segments: [] });
+    lines.push(heading(`${t('panel.usage.turns')} · ${view.turns.length}`));
+    if (view.turns.length === 0) {
+        lines.push(note(t('panel.usage.noTurns')));
+    }
+    else {
+        const withTurn = [
+            { label: () => t('panel.usage.colTurn'), value: (row) => `#${row.turn}`, width: 7 },
+            ...BUCKET_COLUMNS.map(column => ({ ...column, value: (row) => column.value(row.usage) })),
+        ];
+        lines.push(...table(withTurn, [...view.turns].reverse(), row => modelLabel(row.model), width, false));
+    }
+    return lines.map(line => boundLine(line, width));
+}

package/vendor/tui/lib/render/width.mjs

@@ -0,0 +1,191 @@
+/**
+ * Precise terminal-cell width measurement — the single authority every
+ * budget, wrap, and truncation path shares. The previous heuristic
+ * (`codePoint > 0x2e7f ? 2 : 1)) mis-sized Hangul Jamo (narrow), high
+ * non-CJK code points (wide), and emoji: text-default glyphs like ✳ ⚠ ❤
+ * counted 2 while terminals draw 1, and VS16 sequences counted 1 while
+ * terminals draw 2 — the exact drift class the community dsh-TUI string
+ * engine documents (a spinner glyph drifting one column per frame). This
+ * module adapts that engine's rules without its Ink-fork renderer: an ASCII
+ * fast path, grapheme-cluster iteration via Intl.Segmenter (code-point
+ * fallback), a merged East-Asian-Wide/Fullwidth + Emoji_Presentation range
+ * table, text-default emoji = 1, VS16 = 2, marks/selectors/ZWJ = 0.
+ * @module @deepseek-ai/dsh-code/render/width
+ */
+/**
+ * Code-point ranges rendered two cells wide: East Asian Wide/Fullwidth
+ * blocks merged with the Emoji_Presentation set (default-wide emoji) and
+ * regional indicators (flags). Sorted, inclusive, binary-searched.
+ */
+const WIDE_RANGES = [
+    [0x1100, 0x115f],
+    [0x231a, 0x231b],
+    [0x2329, 0x232a],
+    [0x23e9, 0x23ec],
+    [0x23f0, 0x23f0],
+    [0x23f3, 0x23f3],
+    [0x23f8, 0x23fa],
+    [0x25fd, 0x25fe],
+    [0x2614, 0x2615],
+    [0x2648, 0x2653],
+    [0x267f, 0x267f],
+    [0x2693, 0x2693],
+    [0x26a1, 0x26a1],
+    [0x26aa, 0x26ab],
+    [0x26bd, 0x26be],
+    [0x26c4, 0x26c5],
+    [0x26ce, 0x26ce],
+    [0x26d4, 0x26d4],
+    [0x26ea, 0x26ea],
+    [0x26f2, 0x26f3],
+    [0x26f5, 0x26f5],
+    [0x26fa, 0x26fa],
+    [0x26fd, 0x26fd],
+    [0x2705, 0x2705],
+    [0x270a, 0x270b],
+    [0x2728, 0x2728],
+    [0x274c, 0x274c],
+    [0x274e, 0x274e],
+    [0x2753, 0x2755],
+    [0x2757, 0x2757],
+    [0x2795, 0x2797],
+    [0x27b0, 0x27b0],
+    [0x27bf, 0x27bf],
+    [0x2b1b, 0x2b1c],
+    [0x2b50, 0x2b50],
+    [0x2b55, 0x2b55],
+    [0x2e80, 0x303e],
+    [0x3041, 0x33ff],
+    [0x3400, 0x4dbf],
+    [0x4e00, 0xa4cf],
+    [0xa960, 0xa97f],
+    [0xac00, 0xd7a3],
+    [0xf900, 0xfaff],
+    [0xfe10, 0xfe19],
+    [0xfe30, 0xfe4f],
+    [0xff00, 0xff60],
+    [0xffe0, 0xffe6],
+    [0x16fe0, 0x16fe4],
+    [0x17000, 0x18aff],
+    [0x1b000, 0x1b2ff],
+    [0x1f004, 0x1f004],
+    [0x1f0cf, 0x1f0cf],
+    [0x1f18e, 0x1f18e],
+    [0x1f191, 0x1f19a],
+    [0x1f1e6, 0x1f1ff],
+    [0x1f200, 0x1f320],
+    [0x1f32d, 0x1f335],
+    [0x1f337, 0x1f37c],
+    [0x1f37e, 0x1f393],
+    [0x1f3a0, 0x1f3ca],
+    [0x1f3cf, 0x1f3d3],
+    [0x1f3e0, 0x1f3f0],
+    [0x1f3f4, 0x1f3f4],
+    [0x1f3f8, 0x1f43e],
+    [0x1f440, 0x1f440],
+    [0x1f442, 0x1f4fc],
+    [0x1f4ff, 0x1f53d],
+    [0x1f54b, 0x1f54e],
+    [0x1f550, 0x1f567],
+    [0x1f57a, 0x1f57a],
+    [0x1f595, 0x1f596],
+    [0x1f5a4, 0x1f5a4],
+    [0x1f5fb, 0x1f64f],
+    [0x1f680, 0x1f6c5],
+    [0x1f6cc, 0x1f6cc],
+    [0x1f6d0, 0x1f6d2],
+    [0x1f6d5, 0x1f6d7],
+    [0x1f6eb, 0x1f6ec],
+    [0x1f6f4, 0x1f6fc],
+    [0x1f7e0, 0x1f7eb],
+    [0x1f90c, 0x1f93a],
+    [0x1f93c, 0x1f945],
+    [0x1f947, 0x1f9ff],
+    [0x1fa70, 0x1fa7c],
+    [0x1fa80, 0x1fa89],
+    [0x1fa8f, 0x1fac6],
+    [0x1face, 0x1fadc],
+    [0x1fadf, 0x1fae9],
+    [0x1faf0, 0x1faf8],
+    [0x20000, 0x2fffd],
+    [0x30000, 0x3fffd],
+];
+/** Whether one code point falls inside a wide range (binary search). */
+function isWideCodePoint(code) {
+    let low = 0;
+    let high = WIDE_RANGES.length - 1;
+    while (low <= high) {
+        const mid = (low + high) >> 1;
+        const [start, end] = WIDE_RANGES[mid];
+        if (code < start)
+            high = mid - 1;
+        else if (code > end)
+            low = mid + 1;
+        else
+            return true;
+    }
+    return false;
+}
+/** Zero-width code points: combining marks, enclosing marks, format controls. */
+const ZERO_WIDTH = /^[\p{Mn}\p{Me}\p{Cf}]$/u;
+/** Module-cached grapheme segmenter; undefined when the runtime lacks it. */
+let segmenter;
+try {
+    segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+}
+catch {
+    segmenter = undefined;
+}
+/** Split text into grapheme clusters (code points when Segmenter is absent). */
+export function splitGraphemes(text) {
+    if (segmenter === undefined)
+        return Array.from(text);
+    return Array.from(segmenter.segment(text), part => part.segment);
+}
+/** Terminal-cell width of one grapheme cluster. */
+export function graphemeWidth(cluster) {
+    // VS16 requests emoji presentation: ❤️ / ✳️ render two cells even when the
+    // base glyph is text-default (width 1 without the selector).
+    if (cluster.includes('\u{fe0f}', 0))
+        return 2;
+    const first = cluster.codePointAt(0) ?? 0;
+    if (ZERO_WIDTH.test(String.fromCodePoint(first)))
+        return 0;
+    return isWideCodePoint(first) ? 2 : 1;
+}
+/** Terminal-cell width of one code point (surrogate pairs must stay paired). */
+export function codePointWidth(char) {
+    if (ZERO_WIDTH.test(char))
+        return 0;
+    return isWideCodePoint(char.codePointAt(0) ?? 0) ? 2 : 1;
+}
+/**
+ * Terminal-cell width of a string: an ASCII fast path avoids the segmenter
+ * for the overwhelmingly common case; everything else sums grapheme clusters.
+ * Control characters occupy no cells (display sanitization makes them
+ * visible escapes before they ever reach a budget).
+ * @param text - display-safe or raw text to measure.
+ * @returns the column count the terminal will draw.
+ */
+export function stringWidth(text) {
+    let asciiOnly = true;
+    for (let index = 0; index < text.length; index += 1) {
+        if (text.charCodeAt(index) > 0x7f) {
+            asciiOnly = false;
+            break;
+        }
+    }
+    if (asciiOnly) {
+        let columns = 0;
+        for (let index = 0; index < text.length; index += 1) {
+            const code = text.charCodeAt(index);
+            if (code >= 0x20 && code !== 0x7f)
+                columns += 1;
+        }
+        return columns;
+    }
+    let columns = 0;
+    for (const cluster of splitGraphemes(text))
+        columns += graphemeWidth(cluster);
+    return columns;
+}