@toddzheng024/dscode-bundle 0.7.12 → 0.7.13

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

@@ -0,0 +1,157 @@
+/**
+ * Display-boundary sanitization for externally sourced text (model output,
+ * tool payloads, skill descriptions). Control characters — including ANSI
+ * CSI/OSC escape sequences — would otherwise pass through Ink into the
+ * terminal, letting output rewrite the screen or inject prompts. Newlines
+ * survive; everything else in C0/C1 plus DEL becomes a visible `\xNN`
+ * escape, and bidi overrides / invisible format controls / Unicode line and
+ * paragraph separators become a visible `\uXXXX` escape (terminal emulators
+ * that render bidirectional text would otherwise reorder the displayed
+ * glyphs and let a command read as something it is not).
+ *
+ * @module @deepseek-ai/dsh-code/render/text
+ */
+import { graphemeWidth, splitGraphemes, stringWidth } from './width.mjs';
+/**
+ * Compact token count: exact below 1K, then one-decimal-ish K/M.
+ * @param n - token count.
+ * @returns display string.
+ */
+export function formatTokens(n) {
+    const scaled = (v) => v >= 100 ? String(Math.round(v)) : String(Math.round(v * 10) / 10);
+    if (n < 1_000)
+        return String(n);
+    if (n < 1_000_000)
+        return scaled(n / 1_000) + 'K';
+    return scaled(n / 1_000_000) + 'M';
+}
+/** C0 controls except tab (0x09) and newline (0x0a), plus DEL and C1. */
+const CONTROL_ESCAPE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu;
+/**
+ * Bidi overrides and isolates (U+202A-202E, U+2066-2069), the Arabic Letter
+ * Mark (U+061C), directional and zero-width format characters (U+200B,
+ * U+200E/200F, U+2060-2064, U+FEFF), and Unicode line/paragraph separators
+ * (U+2028/2029). Terminal emulators with bidi support (Windows Terminal,
+ * iTerm2, kitty, WezTerm) reorder or hide these, so they must never reach
+ * the terminal raw.
+ */
+const INVISIBLE_ESCAPE = /[\u061c\u200b\u200e\u200f\u2028\u2029\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu;
+/**
+ * Escape control and deceptive characters so externally sourced text cannot
+ * drive the terminal. C0/C1/DEL render as a literal `\xNN` escape; bidi,
+ * invisible-format, and separator controls render as a literal `\uXXXX`
+ * escape. Newlines and tabs survive (budgeted callers normalize tabs).
+ * @param text - raw text from a session event, tool payload, or catalog.
+ * @returns display-safe text with every injectable character made visible.
+ */
+export function displayText(text) {
+    return text
+        .replace(CONTROL_ESCAPE, char => `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`)
+        .replace(INVISIBLE_ESCAPE, char => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
+/** Collapse external text to one terminal-safe logical row. */
+export function singleLineText(text) {
+    return displayText(text).replace(/\r?\n/gu, ' ↵ ').replace(/\t/gu, '  ');
+}
+/**
+ * Truncate one display-safe row without ever exceeding its physical-column
+ * budget. The ellipsis is included inside the budget, matching Codex's popup
+ * truncation contract; the cut walks grapheme clusters so emoji and
+ * combining sequences never split mid-cluster.
+ */
+export function truncateColumns(text, columns) {
+    const limit = Math.max(0, Math.floor(columns));
+    if (limit === 0)
+        return '';
+    if (stringWidth(text) <= limit)
+        return text;
+    const contentLimit = limit - 1;
+    let used = 0;
+    let result = '';
+    for (const cluster of splitGraphemes(text)) {
+        const width = graphemeWidth(cluster);
+        if (used + width > contentLimit)
+            break;
+        result += cluster;
+        used += width;
+    }
+    return `${result}…`;
+}
+/** Punctuation that must never START a physical row (CJK kinsoku tail set). */
+const ROW_START_FORBIDDEN = '，。、；：！？）】」』〉》…‥';
+/** Punctuation that must never END a physical row (CJK kinsoku head set). */
+const ROW_END_FORBIDDEN = '（【「『〈《';
+/**
+ * Keep the newest display-safe text that fits a terminal rectangle, wrapping
+ * FORWARD from the start of the text and slicing the tail rows.
+ *
+ * Forward wrapping is what keeps a streaming tail calm: rows already produced
+ * never re-wrap as tokens append (a backward scan recomputes every wrap point
+ * per chunk and the whole visible block jumps), and the wrap rules match the
+ * settled text's renderer so the flush at turn end does not reflow the block
+ * a second time. CJK kinsoku applies at both edges: closing punctuation
+ * overhangs up to two cells onto the filled row instead of starting the next
+ * one (within the caret column the caller reserves), and opening punctuation
+ * moves down instead of dangling at a row end. Tabs expand to two spaces so
+ * terminal tab stops cannot inflate the physical row count; clusters carry
+ * emoji presentation and combining marks whole.
+ * @param text - raw externally sourced text.
+ * @param columns - available terminal columns.
+ * @param rows - available terminal rows.
+ * @returns a sanitized bounded suffix and whether an earlier prefix was cut.
+ */
+export function displayTail(text, columns, rows) {
+    const columnLimit = Math.max(1, Math.floor(columns));
+    const rowLimit = Math.max(1, Math.floor(rows));
+    const wrapped = [];
+    let current = '';
+    let used = 0;
+    let lastCluster = '';
+    const flush = () => {
+        wrapped.push(current);
+        current = '';
+        used = 0;
+        lastCluster = '';
+    };
+    for (const cluster of splitGraphemes(text)) {
+        if (cluster === '\n') {
+            flush();
+            continue;
+        }
+        const safe = cluster === '\t' ? '  ' : displayText(cluster);
+        // safe can be a multi-character escape literal (\xNN / \uXXXX); only
+        // stringWidth budgets the whole visible escape, never its first byte.
+        const width = stringWidth(safe);
+        if (used > 0 && used + width > columnLimit) {
+            const overhang = width <= 2 && ROW_START_FORBIDDEN.includes(cluster);
+            if (!overhang) {
+                // Kinsoku head: an opening mark at the row edge moves down with the
+                // incoming cluster instead of dangling at the end of the filled row.
+                if (lastCluster !== '' && ROW_END_FORBIDDEN.includes(lastCluster)) {
+                    const carried = lastCluster;
+                    current = current.slice(0, current.length - carried.length);
+                    flush();
+                    current = carried;
+                    used = stringWidth(carried);
+                }
+                else {
+                    flush();
+                }
+            }
+        }
+        current += safe;
+        used += width;
+        lastCluster = cluster;
+    }
+    // A trailing newline means one deliberate empty caret row, but that row
+    // must never evict real content or fake a truncation marker: flush the
+    // content first, decide truncation on content alone, then append the blank
+    // row only when the whole tail still fits the budget.
+    const trailingBlank = current === '' && wrapped.length > 0 && text.endsWith('\n');
+    if (current !== '')
+        flush();
+    const truncated = wrapped.length > rowLimit;
+    const kept = truncated ? wrapped.slice(-rowLimit) : wrapped;
+    const keptRows = trailingBlank && kept.length < rowLimit ? [...kept, ''] : kept;
+    return { text: keptRows.join('\n'), truncated };
+}

package/vendor/tui/lib/render/tool-detail.mjs

@@ -0,0 +1,187 @@
+/**
+ * Expansion payloads for tool cards (the Ctrl+O verbose transcript): the
+ * TUI-side consumption of the harness presentation contract. Mutation and
+ * read tools persist a structured `tool/result.meta` (`diffs`, read
+ * windows, web sources) exactly so a capable UI can replay richer cards than
+ * the model-facing text; this module narrows that opaque JSON defensively —
+ * mirroring the upstream validators — and pre-formats bounded, render-ready
+ * rows. Malformed or absent metadata always degrades to the bounded raw
+ * result text, never throws during replay.
+ *
+ * @module @deepseek-ai/dsh-code/render/tool-detail
+ */
+import { displayText, truncateColumns } from './text.mjs';
+/** Budgets keeping one expanded card bounded on a terminal. */
+const MAX_DIFF_LINES = 200;
+const MAX_READ_LINES = 120;
+const MAX_SOURCES = 10;
+const MAX_RAW_CHARS = 6000;
+const MAX_LINE_COLUMNS = 240;
+/** Hard caps on adversarial `tool/result.meta` before any row is built. */
+const MAX_DIFFS = 8;
+const MAX_DIFF_TEXT_CHARS = 24_000;
+/** Truncate one line to the visible-column budget with an ellipsis marker. */
+function clipLine(text) {
+    return truncateColumns(displayText(text), MAX_LINE_COLUMNS);
+}
+/** Split text into lines, dropping the trailing empty element of a final newline. */
+function toLines(text) {
+    const split = text.split('\n');
+    return split.length > 0 && split[split.length - 1] === '' ? split.slice(0, -1) : split;
+}
+/**
+ * Render one change as removed-then-added rows, hunked by common prefix and
+ * suffix. A null before-image (file create) renders as pure additions. The
+ * budget caps emitted rows and reports the cut, so a whole-file overwrite
+ * never floods the transcript. Inputs are hard-capped before line splitting
+ * and the row list is built incrementally up to the budget — a crafted or
+ * replayed giant diff cannot force a full intermediate rows array.
+ * @param oldText - prior content, or null for a create.
+ * @param newText - content after the change.
+ * @param budget - maximum rows to emit.
+ * @returns the bounded rows and whether they were cut.
+ */
+export function diffRows(oldText, newText, budget) {
+    const oldRaw = oldText ?? '';
+    const newRaw = newText;
+    let inputTruncated = false;
+    let oldSource = oldRaw;
+    let newSource = newRaw;
+    // Bound the working arrays before `toLines` allocates them: keep a
+    // combined-characters share of each side proportional to its input size.
+    const combined = oldRaw.length + newRaw.length;
+    if (combined > MAX_DIFF_TEXT_CHARS) {
+        inputTruncated = true;
+        const oldShare = Math.min(oldRaw.length, Math.floor(MAX_DIFF_TEXT_CHARS * oldRaw.length / combined));
+        const newShare = Math.min(newRaw.length, MAX_DIFF_TEXT_CHARS - oldShare);
+        oldSource = oldRaw.slice(0, oldShare);
+        newSource = newRaw.slice(0, newShare);
+    }
+    const oldLines = oldText === null ? [] : toLines(oldSource);
+    const newLines = toLines(newSource);
+    let prefix = 0;
+    while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix])
+        prefix += 1;
+    let suffix = 0;
+    while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix
+        && oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix])
+        suffix += 1;
+    const removedCount = oldLines.length - prefix - suffix;
+    const addedCount = newLines.length - prefix - suffix;
+    const truncated = inputTruncated || removedCount + addedCount > budget;
+    // Build at most `budget` rows directly; never materialize the full hunk.
+    const rows = [];
+    const removedLimit = Math.min(removedCount, Math.max(0, budget));
+    for (let index = 0; index < removedLimit; index += 1) {
+        rows.push({ mark: '-', text: clipLine(oldLines[prefix + index] ?? '') });
+    }
+    const addedLimit = Math.min(addedCount, Math.max(0, budget - removedLimit));
+    for (let index = 0; index < addedLimit; index += 1) {
+        rows.push({ mark: '+', text: clipLine(newLines[prefix + index] ?? '') });
+    }
+    return { lines: rows, truncated };
+}
+/** Whether `value` is a valid upstream FileDiff (defensive narrowing). */
+function isFileDiff(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const { path, oldText, newText } = value;
+    return typeof path === 'string' && (oldText === null || typeof oldText === 'string') && typeof newText === 'string';
+}
+/** Whether `value` is a valid read-window line (defensive narrowing). */
+function isReadLine(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const { number, text } = value;
+    return typeof number === 'number' && Number.isInteger(number) && number >= 1 && typeof text === 'string';
+}
+/** Whether `value` is a valid web source (defensive narrowing). */
+function isWebSource(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const { url, title, snippet } = value;
+    return typeof url === 'string'
+        && (title === undefined || typeof title === 'string')
+        && (snippet === undefined || typeof snippet === 'string');
+}
+/**
+ * Narrow the opaque `tool/result.meta` into one bounded expansion payload,
+ * mirroring the upstream presenters' degradation ladder: diffs (write/edit),
+ * read windows (read), sources (web_search), fetch summaries (web_fetch), and
+ * the bounded raw result text as the universal fallback.
+ * @param meta - the persisted presentation metadata, when the tool attached one.
+ * @param rawText - the joined text blocks of the result message.
+ * @returns the expansion payload, or undefined when nothing renderable exists.
+ */
+export function toolResultDetail(meta, rawText) {
+    if (typeof meta === 'object' && meta !== null && !Array.isArray(meta)) {
+        const record = meta;
+        const diffs = record['diffs'];
+        // Validate and process only the capped prefix: an adversarial meta with
+        // thousands of diffs never runs `.every` over the full array.
+        if (Array.isArray(diffs) && diffs.length > 0) {
+            const capped = diffs.slice(0, MAX_DIFFS);
+            if (capped.every(isFileDiff)) {
+                const budget = Math.max(8, Math.floor(MAX_DIFF_LINES / capped.length));
+                // Diffs dropped beyond the cap must not vanish silently: the last
+                // kept diff reports the cut exactly like a hunk cut does.
+                const dropped = diffs.length > capped.length;
+                const rendered = capped.map((diff, index) => {
+                    const rows = diffRows(diff.oldText, diff.newText, budget);
+                    return dropped && index === capped.length - 1
+                        ? { path: diff.path, ...rows, truncated: true }
+                        : { path: diff.path, ...rows };
+                });
+                return { kind: 'diff', diffs: rendered };
+            }
+        }
+        const { path, offset, lines, totalLines } = record;
+        if (typeof path === 'string' && Number.isInteger(offset) && offset >= 1
+            && Number.isInteger(totalLines) && totalLines >= 0
+            && Array.isArray(lines)) {
+            // Validate the bounded window only: lines beyond the display cap are
+            // dropped anyway, so a giant persisted window cannot force a full-array
+            // validation pass before the slice.
+            const window = lines.slice(0, MAX_READ_LINES);
+            if (window.every(isReadLine)) {
+                const truncated = lines.length > MAX_READ_LINES;
+                return {
+                    kind: 'read',
+                    path,
+                    offset: offset,
+                    lines: window.map(line => ({ number: line.number, text: clipLine(line.text) })),
+                    totalLines: totalLines,
+                    truncated,
+                };
+            }
+        }
+        const sources = record['sources'];
+        if (Array.isArray(sources)) {
+            const capped = sources.slice(0, MAX_SOURCES);
+            if (capped.every(isWebSource)) {
+                const truncated = sources.length > MAX_SOURCES;
+                return {
+                    kind: 'web-search',
+                    sources: capped.map(source => ({
+                        url: source.url,
+                        title: typeof source.title === 'string' ? source.title : undefined,
+                        snippet: typeof source.snippet === 'string' ? clipLine(source.snippet) : '',
+                    })),
+                    truncated,
+                };
+            }
+        }
+        const { url, statusCode } = record;
+        if (typeof url === 'string' && typeof statusCode === 'number') {
+            return { kind: 'web-fetch', url, statusCode: Math.trunc(statusCode) };
+        }
+    }
+    if (rawText === '')
+        return undefined;
+    const truncated = rawText.length > MAX_RAW_CHARS;
+    return {
+        kind: 'raw',
+        text: truncated ? rawText.slice(0, MAX_RAW_CHARS) : rawText,
+        truncated,
+    };
+}

package/vendor/tui/lib/render/tool-preview.mjs

@@ -0,0 +1,79 @@
+/**
+ * Bounded preview line for a tool invocation's raw JSON arguments: the first
+ * human-meaningful string among the well-known keys (command, path, query, …)
+ * with a fallback to the bounded raw JSON. Shared by the tool card in the
+ * transcript and the approval bar's command preview. Arguments longer than
+ * {@link MAX_PARSE_CHARS} are never parsed: the preview is a display concern,
+ * and a synchronous `JSON.parse` plus string copies of an unbounded model
+ * payload must not run on the approval or projection paths.
+ *
+ * @module @deepseek-ai/dsh-code/render/tool-preview
+ */
+/** Keys searched in declaration order when building a preview. */
+const PREVIEW_KEYS = ['command', 'cmd', 'description', 'path', 'pattern', 'query'];
+/**
+ * Raw arguments longer than this are skipped without parsing and fall back
+ * to the bounded raw preview. Well above any realistic command/path/query
+ * string while keeping the synchronous parse cost negligible.
+ */
+const MAX_PARSE_CHARS = 4096;
+/** Bounded raw-arguments fallback shared by the skip-parse and parse-failure paths. */
+function boundedRawPreview(args) {
+    return args.length > 80 ? `${args.slice(0, 77)}...` : args;
+}
+/**
+ * Resolve one bounded preview for raw tool arguments.
+ * @param args - raw JSON arguments string as the model produced it.
+ * @param toolName - the tool the arguments belong to (fallback label).
+ * @returns the preview line; empty when nothing useful resolves.
+ */
+export function toolArgumentsPreview(args, toolName) {
+    if (args === '')
+        return toolName;
+    if (args.length > MAX_PARSE_CHARS)
+        return boundedRawPreview(args);
+    try {
+        const parsed = JSON.parse(args);
+        if (parsed !== null && typeof parsed === 'object') {
+            const record = parsed;
+            for (const key of PREVIEW_KEYS) {
+                const value = record[key];
+                if (typeof value === 'string' && value !== '')
+                    return value;
+            }
+        }
+    }
+    catch {
+        // Raw JSON parse failed: fall through to the bounded raw arguments.
+    }
+    return boundedRawPreview(args);
+}
+/** Visible budget for one delegation prompt row on the tool card. */
+const MAX_PROMPT_CHARS = 160;
+/**
+ * Bounded prompt preview for delegation-style tools (`subagent`): the
+ * `prompt` argument rendered as the card's second row, so the transcript
+ * shows what the child agent was asked — not just its description label —
+ * while it runs (Codex's SpawnAgent card preview). Anything else returns ''.
+ * @param toolName - the tool the arguments belong to.
+ * @param args - raw JSON arguments string as the model produced it.
+ * @returns the one-line prompt preview, or '' when none applies.
+ */
+export function toolPromptPreview(toolName, args) {
+    if (toolName !== 'subagent' || args === '' || args.length > MAX_PARSE_CHARS)
+        return '';
+    try {
+        const parsed = JSON.parse(args);
+        if (parsed === null || typeof parsed !== 'object')
+            return '';
+        const prompt = parsed['prompt'];
+        if (typeof prompt !== 'string' || prompt === '')
+            return '';
+        const flat = prompt.replace(/\s+/gu, ' ').trim();
+        return flat.length > MAX_PROMPT_CHARS ? `${flat.slice(0, MAX_PROMPT_CHARS - 1)}…` : flat;
+    }
+    catch {
+        // Malformed arguments degrade to no prompt row, never a thrown parse.
+        return '';
+    }
+}