@itookit/dsht 0.2.1 → 0.2.4

package/dist/status.js

@@ -1,9 +1,11 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /** Terminal status from host projections; cumulative usage and estimated context stay distinct. */
+import { useTheme } from "./theme.js";
 import { memo, useEffect, useState } from 'react';
 import { Box, Text, useStdout } from 'ink';
 import wrapAnsi from 'wrap-ansi';
 import { costText } from "./cost.js";
+import { toolLine } from "./transcript.js";
 import { safeText } from "./wire.js";
 /** Format elapsed wall time, clamping clock skew instead of displaying negative durations.
  * @param milliseconds - Elapsed duration.
@@ -12,6 +14,8 @@ import { safeText } from "./wire.js";
 export function elapsedTime(milliseconds) {
     const seconds = Math.max(0, Math.floor(milliseconds / 1000));
     const minutes = Math.floor(seconds / 60);
+    if (minutes === 0)
+        return `${seconds}s`;
     return `${minutes >= 60 ? `${Math.floor(minutes / 60)}h ` : ''}${minutes % 60}m ${seconds % 60}s`;
 }
 /** Produce compact metadata lines without inferring missing provider measurements.
@@ -41,47 +45,55 @@ export function metricLines(values, defaultModel, running) {
     ];
 }
 /** Fit the status summary to one terminal row; details remain available through /status.
- * @param fields - Priority-ordered status fields, followed by optional details.
+ * @param fields - Activity, model, cost, context, and cumulative usage groups in display order.
  * @param width - Available terminal columns.
  * @returns A terminal-safe single line, shortened by display width.
  */
 export function compactStatus(fields, width) {
+    return compactStatusFields(fields, width).filter(Boolean).join('   ');
+}
+/** Keep group identities while fitting plain text; ANSI styling is applied only after layout. */
+function compactStatusFields(fields, width) {
+    if (width <= 0)
+        return [];
     const clean = fields.map(value => safeText(value).replace(/[\r\n\t]/g, ' '));
-    const fit = (value, size) => {
-        if (size < 2)
-            return size === 1 ? '…' : '';
-        const wrapped = wrapAnsi(value, size, { hard: true, wordWrap: false, trim: false });
-        return wrapped.includes('\n') ? wrapAnsi(value, size - 1, { hard: true, wordWrap: false, trim: false }).split('\n')[0] + '…' : value;
-    };
-    const joins = (values) => values.filter(Boolean).join(' · ');
-    const fits = (value) => !wrapAnsi(value, Math.max(1, width), { hard: true, wordWrap: false, trim: false }).includes('\n');
-    if (fits(joins(clean)))
-        return joins(clean);
-    const core = clean.slice(0, 5);
-    core[1] = fit(core[1] ?? '', Math.max(8, Math.min(28, Math.floor(width / 3))));
-    core[2] = fit(core[2] ?? '', Math.max(6, Math.min(20, Math.floor(width / 5))));
-    for (let size = Math.floor(width / 3); size >= 6 && !fits(joins(core)); size--) {
-        core[1] = fit(clean[1] ?? '', size);
-        core[2] = fit(clean[2] ?? '', Math.max(5, Math.floor(size * 0.6)));
+    const join = () => clean.filter(Boolean).join('   ');
+    const fits = () => !wrapAnsi(join(), width, { hard: true, wordWrap: false, trim: false }).includes('\n');
+    if (fits())
+        return clean;
+    // Keep the stable activity column while it fits; reclaim it on narrow terminals.
+    clean[0] = clean[0]?.trimEnd() ?? '';
+    if (fits())
+        return clean;
+    clean[3] = (clean[3] ?? '').replace(/[█░]+ /u, '');
+    if (fits())
+        return clean;
+    clean[1] = toolLine(clean[1] ?? '', Math.max(8, Math.min(24, Math.floor(width / 4))));
+    if (fits())
+        return clean;
+    for (const index of [4, 2, 1, 3]) {
+        clean[index] = '';
+        if (fits())
+            return clean;
     }
-    const extras = clean.slice(5);
-    while (extras.length && !fits(joins([...core, ...extras])))
-        extras.pop();
-    return fit(joins([...core, ...extras]), width);
+    return [toolLine(join(), width)];
 }
+/** Compact token counts; one formatter is reused because construction dominates the format cost. */
+const compactNumber = new Intl.NumberFormat('en', { notation: 'compact', maximumFractionDigits: 1 });
 /** Render a live clock and selected-session metadata; the timer belongs to this mounted bar. */
-export const StatusBar = memo(function StatusBar({ controller, expanded = false }) {
+export const StatusBar = memo(function StatusBar({ controller, expanded = false, width, paused = false }) {
+    const theme = useTheme();
     const { stdout } = useStdout();
     const [now, setNow] = useState(Date.now);
     const running = controller.running;
     const since = controller.workingSince;
     useEffect(() => {
         setNow(Date.now());
-        if (!running)
+        if (!running || paused)
             return;
         const timer = setInterval(() => setNow(Date.now()), 1000);
         return () => clearInterval(timer);
-    }, [running, since]);
+    }, [running, since, paused]);
     const state = controller.state;
     const workspace = state.workspaces.find(item => item.workspaceId === state.workspaceId);
     const view = controller.telemetry.view(state.sessionId);
@@ -94,32 +106,38 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false
     if (!expanded) {
         const selection = record(view.values.modelSelection);
         const route = record(running ? selection.lastUsed ?? selection.next ?? state.defaultModel : selection.next ?? selection.lastUsed ?? state.defaultModel);
-        const model = typeof route.model === 'string' ? `${route.model}${typeof route.reasoningEffort === 'string' ? ` (${route.reasoningEffort})` : ''}` : 'model ?';
+        const model = typeof route.model === 'string' ? `${route.model.replace(/^deepseek-/, '')}${typeof route.reasoningEffort === 'string' ? ` · ${route.reasoningEffort}` : ''}` : 'model ?';
         const pressure = record(view.values.contextPressure);
         const used = numeric(pressure.projectedTokens) ?? numeric(pressure.pressureTokens);
         const capacity = numeric(pressure.contextWindow);
+        const percent = used !== undefined && capacity !== undefined && capacity > 0 ? Math.min(100, Math.round(used / capacity * 100)) : undefined;
+        const filled = percent === undefined ? 0 : Math.round(percent / 10);
+        const context = percent === undefined ? 'ctx ?' : `${'█'.repeat(filled)}${'░'.repeat(10 - filled)} ~${percent}%`;
         const usage = record(view.values.tokenUsage);
         const buckets = [usage.uncachedInputTokens, usage.outputTokens, usage.cacheReadTokens, usage.cacheWriteTokens].map(numeric);
         const total = buckets.every(value => value !== undefined) ? buckets.reduce((a, b) => a + b, 0) : undefined;
-        const compactCount = (value) => value === undefined ? '?' : new Intl.NumberFormat('en', { notation: 'compact', maximumFractionDigits: 1 }).format(value);
-        const activity = running ? `Working ${since === undefined ? '?' : elapsedTime(now - since)}${state.transcript.activeTurnStartedAt === undefined ? '~' : ''}` : 'Idle';
+        const compactCount = (value) => value === undefined ? '?' : compactNumber.format(value);
+        const activity = running ? `◐ Working · ${since === undefined ? '?' : elapsedTime(now - since)}${state.transcript.activeTurnStartedAt === undefined ? '~' : ''} · Ctrl+C Stop` : '● Ready';
+        const warning = state.controlError || state.modelError || coverage === 'partial' ? '! ' : '';
         const fields = [
-            `${!state.online ? 'Offline · ' : ''}${state.controlError || state.modelError || coverage === 'partial' ? '! ' : ''}${activity}`,
-            model, `ws: ${workspace ? workspace.title : '—'}`,
-            `ctx: ${used !== undefined && capacity !== undefined && capacity > 0 ? `~${Math.min(100, Math.round(used / capacity * 100))}%` : '?'}`,
-            `tok: ${compactCount(total)}`,
-            `in/out: ${compactCount(buckets[0])}/${compactCount(buckets[1])}`,
-            `cache: ${compactCount(buckets[2])}/${compactCount(buckets[3])}`,
-            `q:${count(view.queued)} jobs:${count(view.jobs)}`,
-            running ? 'Esc/^C stop' : '^C exit', '/status',
+            `${warning}${!state.online ? 'Offline · ' : ''}${activity}`.padEnd(31),
+            model,
+            costs ? `${costs.hasSession(state.sessionId) ? compactCost(costs.total(state.sessionId)) : '?'}/${compactCost(costs.total(undefined, 1, Date.now()))}` : '?/?',
+            context,
+            `${count(numeric(record(view.values.sessionStats).turns))} turns · ${compactCount(total)} tok`,
+        ];
+        const fitted = compactStatusFields(fields, width ?? Math.max(1, (stdout.columns ?? 80) - 2));
+        const colors = [
+            !state.online ? theme.status.offline : warning ? theme.status.warning : running ? theme.status.working : theme.status.ready,
+            theme.status.model, costs ? theme.status.cost : theme.status.usage,
+            percent === undefined ? theme.status.usage : percent >= 95 ? theme.status.critical : percent >= 80 ? theme.status.warning : theme.status.context,
+            theme.status.usage,
         ];
-        const width = Math.max(1, (stdout.columns ?? 80) - 2);
-        const fee = costs ? ` · S:${sessionCost} D:${todayCost}` : '';
-        return _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [compactStatus(fields, Math.max(1, width - fee.length)), fee] });
+        return _jsx(Text, { wrap: "truncate-end", children: fitted.map((text, index) => text ? _jsxs(Text, { children: [fitted.slice(0, index).some(Boolean) && _jsx(Text, { color: theme.colors.muted, children: '   ' }), _jsx(Text, { color: colors[index], bold: index === 0, children: text })] }, index) : null) });
     }
-    return _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { color: running ? 'yellow' : 'gray', children: [running
-                        ? `Working ${since === undefined ? 'unknown duration' : elapsedTime(now - since)}${state.transcript.activeTurnStartedAt === undefined ? ' (observed)' : ''} · Esc / Ctrl+C stop`
-                        : 'Idle · Ctrl+C exit', !state.online ? ' · disconnected, last known status' : ''] }), state.sessionId && _jsxs(Text, { children: ["Session ID: ", safeText(state.sessionId)] }), _jsxs(Text, { wrap: "truncate-end", children: ["Workspace: ", safeText(label)] }), metricLines(view.values, state.defaultModel, running).map((line, index) => _jsx(Text, { dimColor: true, children: safeText(line) }, index)), costs && _jsxs(Text, { dimColor: true, children: ["Cost (CNY estimate): Session ", sessionCost, " \u00B7 Today ", todayCost] }), costs && coverage === 'partial' && _jsxs(Text, { color: "yellow", children: ["Cost coverage incomplete: ", costs.error ? safeText(costs.error) : 'no complete scan yet'] }), _jsxs(Text, { dimColor: true, children: ["Queued: ", count(view.queued), " \u00B7 Active jobs: ", count(view.jobs)] }), state.controlError && _jsx(Text, { color: "yellow", children: safeText(state.controlError) }), state.modelError && _jsxs(Text, { color: "yellow", children: ["Model catalog unavailable: ", safeText(state.modelError)] })] });
+    return _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: theme.border, paddingX: 1, children: [_jsxs(Text, { color: running ? theme.colors.context : theme.colors.muted, children: [running
+                        ? `◐ Working · ${since === undefined ? 'unknown duration' : elapsedTime(now - since)}${state.transcript.activeTurnStartedAt === undefined ? ' (observed)' : ''} · Ctrl+C Stop`
+                        : '● Ready · Ctrl+C exit', !state.online ? ' · disconnected, last known status' : ''] }), _jsxs(Text, { wrap: "truncate-end", children: ["Host: ", safeText(controller.base), " \u00B7 ", safeText(state.status)] }), state.sessionId && _jsxs(Text, { children: ["Session ID: ", safeText(state.sessionId)] }), controller.sessionMode && _jsxs(Text, { children: ["Mode: ", safeText(controller.sessionMode)] }), _jsxs(Text, { wrap: "truncate-end", children: ["Workspace: ", safeText(label)] }), metricLines(view.values, state.defaultModel, running).map((line, index) => _jsx(Text, { dimColor: true, children: safeText(line) }, index)), costs && _jsxs(Text, { dimColor: true, children: ["Cost (CNY estimate): Session ", sessionCost, " \u00B7 Today ", todayCost] }), costs && coverage === 'partial' && _jsxs(Text, { color: theme.colors.context, children: ["Cost coverage incomplete: ", costs.error ? safeText(costs.error) : 'no complete scan yet'] }), _jsxs(Text, { dimColor: true, children: ["Turns: ", count(numeric(record(view.values.sessionStats).turns))] }), _jsxs(Text, { dimColor: true, children: ["Queued: ", count(view.queued), " \u00B7 Active jobs: ", count(view.jobs)] }), state.controlError && _jsx(Text, { color: theme.colors.context, children: safeText(state.controlError) }), state.presetError && _jsxs(Text, { color: theme.colors.context, children: ["Preset names unavailable: ", safeText(state.presetError)] }), state.modelError && _jsxs(Text, { color: theme.colors.context, children: ["Model catalog unavailable: ", safeText(state.modelError)] })] });
 });
 function record(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
@@ -134,3 +152,6 @@ function modelName(value) {
         return 'unknown';
     return safeText(`${model.provider}/${model.model}${typeof model.reasoningEffort === 'string' ? ` (${model.reasoningEffort})` : ''}`);
 }
+function compactCost(total) {
+    return `~¥${total.amount.toFixed(2)}${total.unknown || total.estimated ? '*' : ''}`;
+}

package/dist/telemetry.d.ts

@@ -2,10 +2,13 @@
 import { type ObjectValue } from './wire.ts';
 /** Generation-local projection, inbox and background-job data for every session. */
 export declare class Telemetry {
+    private readonly retainedKeys?;
     private entries;
     private queues;
     private jobs;
     ready: boolean;
+    /** Optionally retain only projection capabilities consumed by this client. */
+    constructor(retainedKeys?: ReadonlySet<string> | undefined);
     /** Replace all control state on a new stream baseline, then accept replacement frames.
      * @param value - One decoded session/control frame.
      */

package/dist/telemetry.js

@@ -2,10 +2,15 @@
 import { array, object, string } from "./wire.js";
 /** Generation-local projection, inbox and background-job data for every session. */
 export class Telemetry {
+    retainedKeys;
     entries = new Map();
     queues = new Map();
     jobs = new Map();
     ready = false;
+    /** Optionally retain only projection capabilities consumed by this client. */
+    constructor(retainedKeys) {
+        this.retainedKeys = retainedKeys;
+    }
     /** Replace all control state on a new stream baseline, then accept replacement frames.
      * @param value - One decoded session/control frame.
      */
@@ -36,6 +41,8 @@ export class Telemetry {
                 return;
             if (frame.value === undefined)
                 throw new Error('Missing projection value');
+            if (this.retainedKeys && !this.retainedKeys.has(key))
+                return;
             entry.values[key] = frame.value;
             entry.revisions.set(key, seq);
         }
@@ -60,6 +67,8 @@ export class Telemetry {
         if (seq < entry.baseline)
             return;
         for (const key of new Set([...Object.keys(entry.values), ...Object.keys(values)])) {
+            if (this.retainedKeys && !this.retainedKeys.has(key))
+                continue;
             if ((entry.revisions.get(key) ?? -1) > seq)
                 continue;
             if (Object.hasOwn(values, key))

package/dist/theme.d.ts

@@ -0,0 +1,15 @@
+import type { RowKind } from './history.ts';
+/** Themes provide semantic roles so components never depend on palette-specific color names. */
+export interface Theme {
+    name: string;
+    colors: Record<RowKind, string>;
+    status: Record<'working' | 'ready' | 'offline' | 'model' | 'cost' | 'context' | 'warning' | 'critical' | 'usage', string>;
+    accent: string;
+    border: string;
+}
+/** Catppuccin Mocha, preserving the terminal background and its color-capability fallback. */
+export declare const mocha: Theme;
+/** Components read semantic colors from the current application theme. */
+export declare const ThemeContext: import("react").Context<Theme>;
+/** Return the theme selected by the surrounding application provider. */
+export declare function useTheme(): Theme;

package/dist/theme.js

@@ -0,0 +1,15 @@
+/** Semantic terminal palette. Source: https://catppuccin.com/palette/ (Mocha). */
+import { createContext, useContext } from 'react';
+/** Catppuccin Mocha, preserving the terminal background and its color-capability fallback. */
+export const mocha = {
+    name: 'Catppuccin Mocha',
+    colors: { user: '#89b4fa', assistant: '#a6e3a1', context: '#f9e2af', text: '#cdd6f4',
+        reasoning: '#cba6f7', tool: '#89dceb', success: '#a6e3a1', error: '#f38ba8', muted: '#a6adc8' },
+    status: { working: '#f9e2af', ready: '#a6e3a1', offline: '#f38ba8', model: '#cba6f7',
+        cost: '#89dceb', context: '#a6e3a1', warning: '#f9e2af', critical: '#f38ba8', usage: '#a6adc8' },
+    accent: '#cba6f7', border: '#6c7086',
+};
+/** Components read semantic colors from the current application theme. */
+export const ThemeContext = createContext(mocha);
+/** Return the theme selected by the surrounding application provider. */
+export function useTheme() { return useContext(ThemeContext); }

package/dist/transcript.d.ts

@@ -1,7 +1,9 @@
+import type { HistoryLimits } from './memory.ts';
 import { type Json } from './wire.ts';
 interface ToolSummary {
     name: string;
     operation?: string;
+    command?: string;
 }
 /** Fit a tool operation to one terminal row without exposing the result body.
  * @param text - Tool name, status icon and optional operation.
@@ -9,23 +11,69 @@ interface ToolSummary {
  * @returns A single line with an ellipsis when shortened.
  */
 export declare function toolLine(text: string, width: number): string;
-/** Render known content blocks and preserve unknown plugin blocks as JSON. */
-export declare function contentText(content: Json | undefined, tools?: ReadonlyMap<string, ToolSummary>, width?: number): string;
+/** Render known content blocks and preserve unknown plugin blocks as JSON.
+ * @param content - Message content blocks.
+ * @param tools - Tool summaries by call ID, when retained history provides them.
+ * @param width - Available terminal columns.
+ * @param reasoning - `full` keeps streamed reasoning at length; `row` folds a committed block into one row.
+ * @returns Blocks joined by newlines.
+ */
+export declare function contentText(content: Json | undefined, tools?: ReadonlyMap<string, ToolSummary>, width?: number, reasoning?: 'row' | 'full'): string;
+/** Semantic content stays separate from terminal rows, styles, and fold state. */
+export interface MessagePart {
+    kind: 'text' | 'reasoning' | 'tool' | 'success' | 'error';
+    text: string;
+    /** Closed live reasoning can fold before the assistant message is committed. */
+    closed?: boolean;
+}
 /** A displayed message retains the durable sequence for stable reconciliation. */
 export interface Message {
     seq: number;
     role: string;
     text: string;
+    parts: MessagePart[];
     compact?: boolean;
+    /** One-row rendering of committed reasoning, used only while the conversation folds reasoning. */
+    folded?: string;
+}
+/** Lightweight reasoning navigation row; summaries never contain a copy of the full thought. */
+export interface ThoughtEntry {
+    seq: number;
+    promptSeq?: number;
+    prompt: string;
+    preview: string;
 }
 /** Opening snapshots replace all state; durable events are deduplicated by sequence. */
 export declare class Transcript {
+    private sizes;
+    private storedBytes;
+    private throughSeq;
+    private promptBeforeWindow;
+    private disposed;
+    /** Increments when cached bodies are evicted, so view state can drop obsolete references. */
+    memoryRevision: number;
+    private transientSeqs;
     private events;
     private blocks;
+    private thoughtIndex;
+    private liveProjection;
+    private closedBlocks;
+    private oldestSeq;
+    private turnMarker;
     private attempt;
     private nextIndex;
     private revision;
     private legacyStream;
+    private keysDirty;
+    private sortedSeqs;
+    private projectionRevision;
+    private projection;
+    private displaySeqsRevision;
+    private displayed;
+    private displayedMessages;
+    private legacyDirty;
+    private legacyPosition;
+    private legacySeq;
     /** Changes whenever a follow frame or older page can affect the rendered transcript. */
     version: number;
     cursor: number;
@@ -35,19 +83,49 @@ export declare class Transcript {
     accept(value: unknown): void;
     /** Add an older page without replacing the live tail. */
     addPage(value: unknown): void;
+    /** Durable read cutoff includes followed records that were not present in the opening snapshot. */
+    get readThrough(): number;
+    /** Estimated UTF-16 JSON payload bytes; excludes object overhead and unfinished stream blocks. */
+    get retainedBytes(): number;
+    /** Release reloadable prefix records with hysteresis, retaining a recent tail and active legacy chunks.
+     * @param limits - Soft record and payload budgets; callers suspend this operation while reading history.
+     * @returns Number of removed records. Paging remains possible at the advanced durable cutoff.
+     */
+    trimHistory(limits: HistoryLimits): number;
+    /** Empty an inactive session immediately; late frames cannot repopulate a disposed transcript. */
+    dispose(): void;
+    private dropProjections;
+    private storeEvent;
+    private deleteEvent;
     /** Start of the open durable turn, when its timestamp is present in the retained window. */
     get activeTurnStartedAt(): number | undefined;
-    /** Earliest retained record, used with the opening cursor for backward paging. */
+    /** Cached prompt/reasoning summaries, oldest first; stream deltas never invalidate this index. */
+    get thoughts(): ThoughtEntry[];
+    /** Latest loaded user prompt summary, sharing the durable thought index. */
+    get latestPrompt(): string;
+    /** Number of semantic records and unfinished legacy chunks held by the client. */
+    get retainedRecordCount(): number;
+    /** Earliest loaded record, used with the opening cursor for backward paging. */
     get beforeSeq(): number | undefined;
+    /** Retained sequences in ascending order; resorted only when a retained event changes. */
+    private sortedKeys;
+    /** Sequences of the event types that contribute a displayed message. */
+    private displaySeqs;
     /** Return append-origin conversation only; model-only replacement copies stay hidden. */
     get messages(): Message[];
     /** Project history with single-row tool operations at the caller's terminal width.
      * @param width - Available terminal columns.
-     * @returns Conversation messages with compact tool-only rows.
+     * @returns Conversation messages with compact tool-only rows; the array is shared and must not be mutated.
      */
     messagesForWidth(width: number): Message[];
+    /** Build the message list, reusing each unchanged event's earlier projection at the same width. */
+    private project;
     /** Text from the active attempt is transient and never duplicated into durable history. */
     get liveText(): string;
+    /** Attempt identity resets the view's live fold preference between responses. */
+    get liveAttemptKey(): string | undefined;
+    /** Whether an active attempt has content, without joining its potentially long reasoning. */
+    get hasLiveContent(): boolean;
     /** Whether the active stream contains only tool operations, with no assistant prose. */
     get liveToolOnly(): boolean;
     /** Render live tool operations within a terminal row.
@@ -55,9 +133,16 @@ export declare class Transcript {
      * @returns Transient assistant text with clipped tool rows.
      */
     liveTextForWidth(width: number): string;
+    /** Live semantic blocks; completed reasoning folds independently of the unfinished answer.
+     * @param width - Terminal width used for compact tool summaries.
+     * @returns Ordered blocks without terminal style escapes.
+     */
+    liveParts(width: number): MessagePart[];
     private addRecords;
-    /** Older hosts log chunks directly; replay only the unfinished attempt for live display. */
-    private rebuildLegacyStream;
+    /** Older hosts log chunks directly; fold the unfinished attempt into the live tail for display.
+     * A page behind the folded position, or a replaced event, forces a full re-fold; streamed chunks extend it.
+     */
+    private foldLegacy;
     private validatePackedTiming;
     private chunk;
 }