@toddzheng024/dscode-bundle 0.7.21 → 0.7.23

package/vendor/tui/lib/communication.mjs

@@ -0,0 +1,262 @@
+/**
+ * Live cross-session communication feed: a bounded, display-only projection of
+ * the root session's session-bridge traffic. The transcript store folds tool
+ * cards and hides their arguments, so a `send_session` that is waiting on
+ * another session looks exactly like any other tool call; this module keeps the
+ * direction, the peer, the delivery mode and the outstanding request visible.
+ *
+ * Two event families feed it, both already durable:
+ * - `tool/call` / `tool/result` for `send_session` and `reply_session`, with
+ *   the call arguments carrying target, kind and mode (a result carries no such
+ *   fields, so a failing call is reported only by its paired error).
+ * - `user/message` relayed by the session bridge, which is an inbound message
+ *   from another session or an external source.
+ *
+ * Rows are advisory display state rebuilt from events; nothing here persists or
+ * replays, and a resume re-derives the history from the log.
+ *
+ * @module @deepseek-ai/dsh-code/communication
+ */
+/** Hard row cap for `/tasks`; the newest rows survive. */
+export const MAX_COMMUNICATION_ROWS = 32;
+/** Bound on outstanding requests tracked at once (display state, not a budget). */
+const MAX_WAITING_REQUESTS = 16;
+/** Bounded body preview, matching the activity line's display budget. */
+const MAX_PREVIEW_CHARS = 72;
+/** The plugin name the session bridge stamps on its relayed messages. */
+const BRIDGE_PLUGIN = 'dscode-session-bridge';
+/** Tool names that address another session. */
+const SEND_TOOLS = new Set(['send_session', 'reply_session']);
+/**
+ * One peer identity across both directions. Outbound rows carry the bare
+ * session id from the tool arguments; an inbound relay's bridge label is
+ * `session:<id>`, so the prefix is stripped before they are compared.
+ */
+function peerKey(peer) {
+    return peer.startsWith('session:') ? peer.slice('session:'.length) : peer;
+}
+/** Fold one tool-call argument JSON string into the fields a row needs. */
+function callFields(raw) {
+    if (typeof raw !== 'string' || raw.length > 8192)
+        return { preview: '' };
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { preview: '' };
+    }
+    if (parsed === null || typeof parsed !== 'object')
+        return { preview: '' };
+    const fields = parsed;
+    const text = (value) => (typeof value === 'string' ? value.replace(/\s+/gu, ' ').trim() : '');
+    const peer = text(fields.session_id) || text(fields.request_message_id);
+    const preview = text(fields.text);
+    return {
+        ...(peer === '' ? {} : { peer }),
+        ...(text(fields.kind) === '' ? {} : { kind: text(fields.kind) }),
+        ...(text(fields.mode) === '' ? {} : { mode: text(fields.mode) }),
+        preview: preview.length > MAX_PREVIEW_CHARS ? `${preview.slice(0, MAX_PREVIEW_CHARS - 1)}…` : preview,
+    };
+}
+/**
+ * One relayed message's peer, message kind and bounded text. The bridge stamps
+ * the kind only inside the body header (`[External source: …] [kind/mode]`),
+ * which is its documented presentation contract, so an unrecognised header
+ * leaves the kind undefined and the caller stays conservative: an unknown
+ * inbound message never counts as an answer.
+ */
+function relayFields(data) {
+    if (data === null || typeof data !== 'object')
+        return undefined;
+    const message = data;
+    const source = message.source;
+    if (source === null || typeof source !== 'object')
+        return undefined;
+    const stamp = source;
+    if (stamp.kind !== 'plugin' || stamp.plugin !== BRIDGE_PLUGIN || stamp.form !== 'relay')
+        return undefined;
+    const label = typeof stamp.label === 'string' && stamp.label !== '' ? stamp.label : undefined;
+    const id = typeof stamp.communicationId === 'string' && stamp.communicationId !== '' ? stamp.communicationId : undefined;
+    if (label === undefined && id === undefined)
+        return undefined;
+    const texts = [];
+    if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+            if (typeof block === 'object' && block !== null) {
+                const { type, text } = block;
+                if (type === 'text' && typeof text === 'string')
+                    texts.push(text);
+            }
+        }
+    }
+    const body = texts.join(' ').replace(/\s+/gu, ' ').trim();
+    // The body opens with the bridge's own header line (`[External source: …]
+    // [kind/mode]` plus the message id); the preview is the message under it.
+    const kind = body.match(/\[([a-z]+)\/[a-z]+\]/u)?.[1];
+    const joinLines = texts.join('\n');
+    const joined = joinLines
+        .replace(/^\[External source:[^\]]*\](\s*\[[a-z]+\/[a-z]+\])?\s*/u, '')
+        .replace(/^Message ID:[^\n]*\n?/u, '')
+        .replace(/\s+/gu, ' ')
+        .trim();
+    return {
+        peer: label ?? id ?? 'unknown',
+        ...(kind === undefined ? {} : { kind }),
+        preview: joined.length > MAX_PREVIEW_CHARS ? `${joined.slice(0, MAX_PREVIEW_CHARS - 1)}…` : joined,
+    };
+}
+/**
+ * Fold one root-session event into the feed, returning the same view identity
+ * when the event is not communication traffic.
+ * @param view - the current view.
+ * @param event - one session event from the root session.
+ * @returns the next view, or the same object when nothing changed.
+ */
+export function foldCommunication(view, event) {
+    if (event.type === 'tool/call') {
+        const data = event.data;
+        if (!SEND_TOOLS.has(data.name))
+            return view;
+        const fields = callFields(data.arguments);
+        const row = {
+            id: outboundId(data.callId),
+            direction: 'sent',
+            peer: fields.peer ?? 'unknown',
+            ...(fields.kind === undefined ? {} : { kind: fields.kind }),
+            ...(fields.mode === undefined ? {} : { mode: fields.mode }),
+            preview: fields.preview,
+            at: event.time,
+            pending: true,
+            failed: false,
+        };
+        const rows = bound([...view.rows, row]);
+        // A send in flight is not an outstanding request yet: it becomes one when
+        // the call settles and the message was a request.
+        return { rows, waiting: view.waiting };
+    }
+    if (event.type === 'tool/result') {
+        const data = event.data;
+        const callId = resultCallId(data);
+        if (callId === undefined)
+            return view;
+        const id = outboundId(callId);
+        const index = view.rows.findIndex(row => row.id === id);
+        if (index === -1)
+            return view;
+        const settled = { ...view.rows[index], pending: false, failed: resultFailed(data) };
+        const rows = view.rows.map((row, at) => (at === index ? settled : row));
+        const answers = settled.kind === 'request' && !settled.failed;
+        return {
+            rows,
+            waiting: answers ? markWaiting(view.waiting, settled) : view.waiting,
+        };
+    }
+    if (event.type === 'user/message') {
+        const relay = relayFields(event.data);
+        if (relay === undefined)
+            return view;
+        const row = { id: inboundId(event.data, event.seq), direction: 'received', ...(relay.kind === undefined ? {} : { kind: relay.kind }), peer: relay.peer, preview: relay.preview, at: event.time, pending: false, failed: false };
+        return {
+            rows: bound([...view.rows, row]),
+            // Only the single final reply answers a request; a bare notify from the
+            // same peer must not clear a turn that is still blocked on an answer.
+            waiting: relay.kind === 'reply' ? clearWaiting(view.waiting, row.peer) : view.waiting,
+        };
+    }
+    return view;
+}
+/** Outbound row identity, namespaced so an inbound id can never collide with it. */
+function outboundId(callId) {
+    return `sent:${callId}`;
+}
+/** Inbound row identity, namespaced and falling back to the event sequence. */
+function inboundId(data, seq) {
+    return `recv:${relayId(data) ?? seq}`;
+}
+/**
+ * Record one settled request as awaiting its answer. Keyed by the outbound row,
+ * not by peer: a session may have two requests open to one session, and a
+ * peer-keyed entry would let the second send overwrite the first.
+ */
+function markWaiting(waiting, request) {
+    if (waiting.some(entry => entry.id === request.id))
+        return waiting;
+    const next = [...waiting, { id: request.id, peer: request.peer, since: request.at }];
+    return next.length <= MAX_WAITING_REQUESTS ? next : next.slice(next.length - MAX_WAITING_REQUESTS);
+}
+/**
+ * Clear the outstanding requests a reply answers. One reply answers one of the
+ * requests sent to that peer; without a request-id correlation in the relay,
+ * every open request to that peer retires together, which is the conservative
+ * direction — it never leaves the terminal claiming to await an answered peer.
+ */
+function clearWaiting(waiting, peer) {
+    const next = waiting.filter(entry => peerKey(entry.peer) !== peerKey(peer));
+    return next.length === waiting.length ? waiting : next;
+}
+/** Keep only the newest rows. */
+function bound(rows) {
+    return rows.length <= MAX_COMMUNICATION_ROWS ? rows : rows.slice(rows.length - MAX_COMMUNICATION_ROWS);
+}
+/** The peer of a reply, which the tool result does not name: the call it answers. */
+function resultCallId(data) {
+    if (!Array.isArray(data.message?.content))
+        return undefined;
+    for (const block of data.message.content) {
+        if (typeof block === 'object' && block !== null) {
+            const { toolCallId } = block;
+            if (typeof toolCallId === 'string')
+                return toolCallId;
+        }
+    }
+    return undefined;
+}
+/** True when the tool result's block carries `isError`. */
+function resultFailed(data) {
+    if (!Array.isArray(data.message?.content))
+        return false;
+    return data.message.content.some(block => typeof block === 'object' && block !== null && block.isError === true);
+}
+/** The relay's stable message identity, when the bridge stamped one. */
+function relayId(data) {
+    const source = data?.source;
+    return typeof source?.communicationId === 'string' && source.communicationId !== '' ? source.communicationId : undefined;
+}
+/**
+ * Render the `/tasks` listing: one line per communication, newest last, with
+ * the same arrows the activity line and the notices use. A request that is
+ * still open is marked so a blocked turn is readable without opening anything.
+ * @param view - the folded view.
+ * @param limit - the newest rows to show.
+ * @returns the panel text, or a short explanation when there is no traffic.
+ */
+export function communicationPanel(view, limit = 20) {
+    if (view.rows.length === 0)
+        return 'No cross-session messages in this session.';
+    const waiting = new Set(view.waiting.map(entry => peerKey(entry.peer)));
+    const shown = view.rows.slice(-limit);
+    const lines = shown.map(row => {
+        const arrow = row.direction === 'received' ? '←' : '→';
+        const state = row.direction === 'received' ? 'received' : row.failed ? 'failed' : row.pending ? 'sending' : waiting.has(peerKey(row.peer)) ? 'awaiting reply' : 'sent';
+        const kind = row.kind === undefined ? '' : ` ${row.kind}`;
+        const mode = row.mode === undefined ? '' : `/${row.mode}`;
+        const text = row.preview === '' ? '' : ` — ${row.preview}`;
+        return `${arrow} ${row.peer}${kind}${mode} · ${state}${text}`;
+    });
+    const hidden = view.rows.length - shown.length;
+    return [
+        ...(hidden > 0 ? [`(${hidden} older message${hidden === 1 ? '' : 's'} hidden)`] : []),
+        ...lines,
+    ].join('\n');
+}
+/**
+ * Build the empty feed and its folder.
+ * @returns a feed that folds one event at a time through {@link foldCommunication}.
+ * @example
+ * let view = createCommunicationFeed()
+ * view = foldCommunication(view, event)
+ */
+export function createCommunicationFeed() {
+    return { rows: [], waiting: [] };
+}

package/vendor/tui/lib/dscode/chat.mjs

@@ -41,6 +41,40 @@ function thinkingLines(reasoning, width) {
         ? lines
         : [...lines.slice(0, cap), ...textLines('  … ' + (lines.length - cap) + ' more lines · Ctrl+O opens the full history', width, 'dim')];
 }
+/**
+ * Memoize the live-region render by ENTRY IDENTITY. Streaming carried the whole
+ * live region into a re-render per frame (`view.entries` changes identity on
+ * every event), so the same settled-but-unflushed entries were re-wrapped from
+ * scratch ~60 times a second while only the streaming text — which lives in
+ * `view.streaming`, not in an entry — actually changed. The projection replaces
+ * an entry with a new object whenever its content changes (`{...entry}` at every
+ * mutation site), so identity is a sound cache key, and the wrap depends only on
+ * the entry, the column budget and `verbose`.
+ * @returns a `(entry, columns, verbose) => lines` function with a WeakMap cache.
+ */
+export function createChatLinesCache() {
+    // Per wrap context: a width or `verbose` change re-wraps every row. Keying
+    // the maps instead of resetting one map keeps interleaved contexts (two
+    // regions rendering at different widths in one frame) from thrashing.
+    const contexts = new Map();
+    return (entry, columns, verbose = false) => {
+        const width = Math.max(1, Math.floor(columns));
+        const key = `${width}:${verbose ? 1 : 0}`;
+        let cache = contexts.get(key);
+        if (cache === undefined) {
+            cache = new WeakMap();
+            contexts.set(key, cache);
+        }
+        const hit = cache.get(entry);
+        if (hit !== undefined)
+            return hit;
+        // The wrapped width is the same normalized value the key names, so a
+        // fractional column count cannot key one width and wrap at another.
+        const lines = dscodeChatLines(entry, width, verbose);
+        cache.set(entry, lines);
+        return lines;
+    };
+}
 /**
  * Render one transcript entry the DSCODE way: tool rows are quiet unless verbose
  * is on, assistant rows fold their thinking above the answer, and user prompts

package/vendor/tui/lib/dscode/model-search.mjs

@@ -12,14 +12,14 @@
 export function dscodeFilterModels(rows, query, provider) {
     // One provider at a time: the picker lists the routes the session can actually select.
     const directory = provider === void 0 ? rows : rows.filter(row => row.provider === provider);
-    const label = row => String(row.modelName ?? row.model ?? "");
+    const label = (row) => String(row.modelName ?? row.model ?? "");
     // Display order is the label itself, so the list reads alphabetically and digits inside a
     // name compare naturally ("GLM 5.2" before "GLM 5.3"); searching narrows rows, never re-ranks them.
     const byLabel = (left, right) => label(left).localeCompare(label(right), void 0, {
         numeric: true,
         sensitivity: "base"
     }) || String(left.model ?? "").localeCompare(String(right.model ?? "")) || String(left.provider ?? "").localeCompare(String(right.provider ?? ""));
-    const tokenize = text => String(text ?? '').normalize('NFKC').toLowerCase().match(/[a-z]+|[0-9]+|[^\s\x00-\x7f]+/g) ?? [];
+    const tokenize = (text) => String(text ?? '').normalize('NFKC').toLowerCase().match(/[a-z]+|[0-9]+|[^\s\x00-\x7f]+/g) ?? [];
     const raw = String(query ?? '');
     const words = tokenize(raw);
     if (words.length === 0)

package/vendor/tui/lib/dscode/palette.mjs

@@ -0,0 +1,100 @@
+/**
+ * dscode: the command palette's memory. The completion menu ranks by where a
+ * name matches; the palette additionally remembers what this user actually
+ * runs, so the third time `/review` is opened it is already the first row.
+ *
+ * Usage lives in one user-level JSON file (`~/.dsh/dsh-code/palette.json`),
+ * written through the same crash-atomic chain as the statusline file. A missing
+ * file is an empty history and a corrupt one is treated the same way instead of
+ * failing the TUI: losing the sort order must never cost a session.
+ *
+ * @module @deepseek-ai/dsh-code/dscode/palette
+ */
+import { rankByName } from '../render/fuzzy.mjs';
+/** A description longer than this is clipped in the row, never dropped. */
+const MAX_DESCRIPTION = 160;
+/** Parse the persisted usage object; anything unrecognized is dropped. */
+export function parsePaletteUsage(raw) {
+    if (raw === null || typeof raw !== 'object')
+        return {};
+    const source = raw.usage;
+    if (source === null || typeof source !== 'object' || Array.isArray(source))
+        return {};
+    const usage = {};
+    for (const [name, value] of Object.entries(source)) {
+        if (name === '' || value === null || typeof value !== 'object')
+            continue;
+        const entry = value;
+        const lastUsed = typeof entry.lastUsed === 'number' && Number.isFinite(entry.lastUsed) ? entry.lastUsed : 0;
+        const uses = typeof entry.uses === 'number' && Number.isFinite(entry.uses) && entry.uses > 0 ? Math.floor(entry.uses) : 0;
+        if (uses === 0)
+            continue;
+        usage[name] = { lastUsed, uses };
+    }
+    return usage;
+}
+/** Serialize the usage map back to the file's shape. */
+export function serializePaletteUsage(usage) {
+    const sorted = {};
+    // Stable key order keeps the file readable and diffable across sessions.
+    for (const name of Object.keys(usage).sort())
+        sorted[name] = usage[name];
+    return JSON.stringify({ usage: sorted }, null, 2) + '\n';
+}
+/** Record one use: the newest timestamp wins, the count accumulates. */
+export function recordPaletteUse(usage, name, now = Date.now()) {
+    if (name === '')
+        return usage;
+    const previous = usage[name];
+    return { ...usage, [name]: { lastUsed: now, uses: (previous?.uses ?? 0) + 1 } };
+}
+/**
+ * Usage weight for sorting. Recency and frequency trade off on a square root,
+ * so a single fresh run overtakes an old favorite but a well-worn command does
+ * not sink the moment another one is used once.
+ */
+function weight(entry, now) {
+    if (entry === undefined || entry.uses <= 0)
+        return 0;
+    const ageDays = Math.max(0, now - entry.lastUsed) / 86400000;
+    return Math.sqrt(entry.uses) / (1 + ageDays);
+}
+/**
+ * Every runnable row for the palette, before a query.
+ *
+ * User-invocable skills are included: the palette is the one place a skill that
+ * the model cannot invoke is still reachable by hand, so hiding it here would
+ * make those skills undiscoverable. Model-only skills keep their full
+ * description so the row states which is which.
+ */
+export function paletteEntries(local, descriptors, skills) {
+    const rows = [];
+    const seen = new Set();
+    const push = (name, description, origin) => {
+        if (name === '' || seen.has(name))
+            return;
+        seen.add(name);
+        rows.push({ name, label: `/${name}`, description: description.slice(0, MAX_DESCRIPTION), origin });
+    };
+    // Local commands shadow the registry (the same precedence dispatch uses).
+    for (const command of local)
+        push(command.name, command.description, 'command');
+    for (const descriptor of descriptors)
+        push(descriptor.name, descriptor.description, 'command');
+    for (const skill of skills)
+        push(skill.name, `skill · ${skill.description}`, 'skill');
+    return rows;
+}
+/**
+ * Rank rows for one query: fuzzy match first, then the usage weight, then the
+ * source order. An empty query is the personal order — most-used, most-recent
+ * commands first — with the untouched catalog keeping its declared order.
+ */
+export function rankPalette(entries, query, usage, now = Date.now()) {
+    // rankByName keeps the source order for equally good matches; stamping each
+    // row once lets the usage sort stay stable without an indexOf per comparison.
+    const matched = rankByName(entries, query).map((entry, order) => ({ entry, order }));
+    return matched
+        .sort((left, right) => weight(usage[right.entry.name], now) - weight(usage[left.entry.name], now) || left.order - right.order)
+        .map(item => item.entry);
+}

package/vendor/tui/lib/dscode/telemetry.mjs

@@ -32,7 +32,7 @@ export function dscodeCacheTone(rate) {
     return 'blue';
 }
 /** Every label the cache figure can carry, across the shipped interface languages. */
-const DSCode_CACHE_LABELS = ['cache hit', '缓存命中', '快取命中', 'キャッシュヒット', '캐시 적중', 'éxitos de caché'];
+const DSCode_CACHE_LABELS = ['cache', '缓存', '快取', 'キャッシュ', '캐시', 'caché'];
 /** The ink colour for a tier, theme-aware for the two ends of the scale. */
 export function dscodeTpsInkColor(tone) {
     const palette = getPalette();
@@ -54,22 +54,29 @@ export function dscodeTpsInkColor(tone) {
  */
 export function dscodeTelemetryParts(value) {
     const result = [];
-    const parts = String(value).split(' | ');
+    const parts = String(value).split(' · ');
     for (const [index, part] of parts.entries()) {
         if (index > 0)
-            result.push({ text: ' | ', tone: null });
-        const match = /^(.+?: )(~?(?:\d+(?:\.\d+)?|--)) tps$/.exec(part);
-        if (match) {
-            const display = match[2];
-            const rate = Number(display.startsWith('~') ? display.slice(1) : display);
-            result.push({ text: match[1], tone: null }, { text: display + ' tps', tone: display ? dscodeTpsTone(rate) : null });
+            result.push({ text: ' · ', tone: null });
+        // A rate figure reserves its columns, so the padding stays outside the tinted
+        // run and only the reading carries the tier.
+        const rate = /^(\s*)(~?(?:\d+(?:\.\d+)?|--)) tps( \S+)?$/.exec(part);
+        if (rate) {
+            const display = rate[2];
+            result.push({ text: rate[1], tone: null }, { text: display + ' tps', tone: dscodeTpsTone(Number(display.startsWith('~') ? display.slice(1) : display)) });
+            // The average's trailing qualifier rides along untinted.
+            if (rate[3] !== undefined)
+                result.push({ text: rate[3], tone: null });
             continue;
         }
-        // Only a recognised cache label at the very end of the line is tinted.
-        const labelled = index === parts.length - 1 ? /^(.*?)(\d+(?:\.\d+)?)%$/.exec(part) : null;
-        const cache = labelled && DSCode_CACHE_LABELS.includes(labelled[1].replace(/:\s*$/, '').trim().toLowerCase()) ? labelled : null;
+        // Only a recognised cache label on the very last figure is tinted; the label
+        // itself and every separator keep the surrounding colour.
+        const labelled = index === parts.length - 1 ? /^(\s*)(\d+(?:\.\d+)?|--)%( \S+)$/.exec(part) : null;
+        const cache = labelled && DSCode_CACHE_LABELS.includes(labelled[3].trim().toLowerCase()) ? labelled : null;
         if (cache) {
             result.push({ text: cache[1], tone: null }, { text: cache[2] + '%', tone: dscodeCacheTone(Number(cache[2])) });
+            if (cache[3] !== undefined)
+                result.push({ text: cache[3], tone: null });
             continue;
         }
         result.push({ text: part, tone: null });