@itookit/dsht 0.2.0 → 0.2.4

package/dist/history-view.js

@@ -0,0 +1,12 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/** Only visible semantic rows become React nodes; ANSI colors are applied after remote text sanitation. */
+import { Text } from 'ink';
+import { useTheme } from "./theme.js";
+/** Render a viewport with role, reasoning, tool and result colors from the selected theme.
+ * @param rows - Already wrapped, terminal-safe visible rows.
+ * @returns Colored text with unchanged row geometry and plain-text role markers.
+ */
+export function HistoryViewport({ rows }) {
+    const theme = useTheme();
+    return _jsx(Text, { children: rows.map((row, index) => _jsxs(Text, { color: theme.colors[row.kind], bold: row.bold, children: [row.text, index < rows.length - 1 ? '\n' : ''] }, index)) });
+}

package/dist/history.d.ts

@@ -1,17 +1,34 @@
-import type { Transcript } from './transcript.ts';
-/** Lay out visible conversation records and retain their first terminal row.
- * @param transcript - Loaded history and active assistant output.
+import { type Message, type MessagePart, type Transcript } from './transcript.ts';
+/** Default fold mode; individual sequence overrides are view state, never stored content. */
+export type Reasoning = 'row' | 'full';
+/** Color semantics are independent of the selected terminal palette. */
+export type RowKind = MessagePart['kind'] | 'user' | 'assistant' | 'context' | 'muted';
+/** One visible terminal row; no remote ANSI is allowed into its text. */
+export interface HistoryRow {
+    text: string;
+    kind: RowKind;
+    bold?: boolean;
+    seq?: number;
+}
+/** Drop all terminal rows and layout metadata for an evicted or inactive transcript.
+ * @param transcript - Transcript whose previously returned layout is no longer used.
+ */
+export declare function releaseHistoryLayout(transcript: Transcript): void;
+/** Lay out an indexed conversation without concatenating its historical rows on every stream frame.
+ * @param transcript - Selected session's semantic content and unfinished assistant output.
  * @param width - Available terminal columns.
- * @returns Rows, messages for the history picker, and record-to-row offsets.
+ * @param reasoning - Global committed/completed reasoning fold mode.
+ * @param overrides - Sequences whose fold mode differs from the global mode; replace the set on changes.
+ * @param liveReasoning - Fold mode for completed blocks in the unfinished assistant attempt.
+ * @returns Row count, sequence offsets, and a viewport reader; `lines` materializes all rows for exports only.
  */
-export declare function historyLayout(transcript: Transcript, width: number): {
-    messages: import("./transcript.ts").Message[];
-    lines: string[];
+export declare function historyLayout(transcript: Transcript, width: number, reasoning?: Reasoning, overrides?: ReadonlySet<number>, liveReasoning?: Reasoning): {
+    messages: Message[];
     offsets: Map<number, number>;
     first: number | undefined;
+    length: number;
+    liveOffset: number;
+    viewport: (start: number, end: number) => HistoryRow[];
+    readonly cachedRowCount: number;
+    readonly lines: string[];
 };
-/** Parse an exact visible-record sequence or an endpoint alias.
- * @param value - Text after /jump.
- * @returns A non-negative sequence, first, or last.
- */
-export declare function jumpTarget(value: string): number | 'first' | 'last';

package/dist/history.js

@@ -1,32 +1,177 @@
-/** Width-aware history layout shared by scrolling and explicit message jumps. */
+/** Indexed semantic history with bounded terminal-row caching and viewport-only materialization. */
 import wrapAnsi from 'wrap-ansi';
-/** Lay out visible conversation records and retain their first terminal row.
- * @param transcript - Loaded history and active assistant output.
- * @param width - Available terminal columns.
- * @returns Rows, messages for the history picker, and record-to-row offsets.
- */
-export function historyLayout(transcript, width) {
-    const wrap = (value) => wrapAnsi(value, width, { hard: true }).split('\n');
-    const messages = transcript.messagesForWidth(width);
-    const lines = [];
-    const offsets = new Map();
-    for (const message of messages) {
-        offsets.set(message.seq, lines.length);
-        lines.push(...(message.compact ? [] : [message.role]), ...wrap(message.text), '');
+import { toolLine } from "./transcript.js";
+/** A session owns one layout cache; dropped sessions release their entire cache. */
+class LayoutIndex {
+    width;
+    reasoning;
+    overrides;
+    messages = [];
+    segments = [];
+    offsets = new Map();
+    length = 0;
+    cache = new Map();
+    cacheSize = 0;
+    // Bound both row objects and long rows. Full semantic content remains available for search.
+    maxRows = 2048;
+    heights = new WeakMap();
+    constructor(width, reasoning, overrides) {
+        this.width = width;
+        this.reasoning = reasoning;
+        this.overrides = overrides;
+    }
+    rows(message, reasoning, heading) {
+        const cached = this.cache.get(message);
+        if (cached?.width === this.width && cached.reasoning === reasoning && cached.heading === heading) {
+            this.cache.delete(message);
+            this.cache.set(message, cached);
+            return cached.rows;
+        }
+        const rows = messageRows(message, this.width, reasoning, heading);
+        if (cached) {
+            this.cache.delete(message);
+            this.cacheSize -= cached.rows.length;
+        }
+        if (rows.length <= this.maxRows && rows.reduce((sum, row) => sum + row.text.length, 0) <= 256 * 1024) {
+            while (this.cacheSize + rows.length > this.maxRows) {
+                const key = this.cache.keys().next().value;
+                this.cacheSize -= this.cache.get(key).rows.length;
+                this.cache.delete(key);
+            }
+            this.cache.set(message, { width: this.width, reasoning, heading, rows });
+            this.cacheSize += rows.length;
+        }
+        return rows;
+    }
+    dispose() {
+        this.messages = [];
+        this.segments = [];
+        this.offsets.clear();
+        this.cache.clear();
+        this.cacheSize = 0;
+        this.length = 0;
+        this.heights = new WeakMap();
+    }
+    get cachedRowCount() { return this.cacheSize; }
+    get assistantSeen() { return this.segments.at(-1)?.assistantSeen ?? false; }
+    update(messages) {
+        if (messages === this.messages)
+            return;
+        // Appended durable messages extend the row index; replacements and older pages rebuild offsets.
+        let prefix = 0;
+        while (prefix < this.messages.length && prefix < messages.length && this.messages[prefix] === messages[prefix])
+            prefix++;
+        if (prefix < this.messages.length) {
+            const retained = new Set(messages);
+            for (const [message, cached] of this.cache)
+                if (!retained.has(message)) {
+                    this.cacheSize -= cached.rows.length;
+                    this.cache.delete(message);
+                }
+            this.segments.length = prefix;
+            this.offsets = new Map(this.segments.map(segment => [segment.message.seq, segment.start]));
+            this.length = this.segments.at(-1) ? this.segments.at(-1).start + this.segments.at(-1).count : 0;
+        }
+        let assistantSeen = this.assistantSeen;
+        for (let i = prefix; i < messages.length; i++) {
+            const message = messages[i];
+            if (message.role === 'You')
+                assistantSeen = false;
+            const heading = !message.compact && (message.role !== 'Assistant' || !assistantSeen);
+            if (message.role === 'Assistant' && heading)
+                assistantSeen = true;
+            const reasoning = this.overrides.has(message.seq) ? this.reasoning === 'row' ? 'full' : 'row' : this.reasoning;
+            const cached = this.heights.get(message);
+            const count = cached?.width === this.width && cached.reasoning === reasoning && cached.heading === heading ? cached.count : this.rows(message, reasoning, heading).length;
+            this.heights.set(message, { width: this.width, reasoning, heading, count });
+            this.offsets.set(message.seq, this.length);
+            this.segments.push({ message, start: this.length, count, reasoning, heading, assistantSeen });
+            this.length += count;
+        }
+        this.messages = messages;
+    }
+    viewport(start, end) {
+        let lo = 0, hi = this.segments.length;
+        while (lo < hi) {
+            const middle = (lo + hi) >>> 1;
+            const segment = this.segments[middle];
+            if (segment.start + segment.count <= start)
+                lo = middle + 1;
+            else
+                hi = middle;
+        }
+        const rows = [];
+        for (let i = lo; i < this.segments.length; i++) {
+            const segment = this.segments[i];
+            if (segment.start >= end)
+                break;
+            rows.push(...this.rows(segment.message, segment.reasoning, segment.heading).slice(Math.max(0, start - segment.start), end - segment.start));
+        }
+        return rows;
     }
-    const live = transcript.liveTextForWidth(width);
-    if (live)
-        lines.push(...(transcript.liveToolOnly ? [] : ['Assistant · streaming']), ...wrap(live));
-    return { messages, lines, offsets, first: transcript.beforeSeq };
 }
-/** Parse an exact visible-record sequence or an endpoint alias.
- * @param value - Text after /jump.
- * @returns A non-negative sequence, first, or last.
+const liveRows = new WeakMap();
+function partRows(parts, width, reasoning, seq) {
+    return parts.flatMap(part => {
+        const cached = seq === undefined ? liveRows.get(part) : undefined;
+        if (cached?.width === width && cached.reasoning === reasoning)
+            return cached.rows;
+        const fold = part.kind === 'reasoning' && reasoning === 'row' && (seq !== undefined || part.closed);
+        const text = fold ? toolLine(`◇ /think${seq === undefined ? ' live' : ` ${seq}`} · ${part.text.slice(2)}`, width) : part.text;
+        const rows = wrapAnsi(text, width, { hard: true, trim: !['tool', 'success', 'error'].includes(part.kind) }).split('\n').map(text => ({ text, kind: part.kind, seq }));
+        if (seq === undefined)
+            liveRows.set(part, { width, reasoning, rows });
+        return rows;
+    });
+}
+function messageRows(message, width, reasoning, heading) {
+    const kind = message.role === 'You' ? 'user' : message.role === 'Context' ? 'context' : 'assistant';
+    const label = kind === 'user' ? '❯ User' : kind === 'context' ? '◆ Context' : '✦ Assistant';
+    return [
+        ...(!heading ? [] : [{ text: label, kind, bold: true, seq: message.seq }]),
+        ...partRows(message.parts, width, reasoning, message.seq),
+        { text: '', kind: 'muted', seq: message.seq },
+    ];
+}
+const indexes = new WeakMap();
+const noOverrides = new Set();
+/** Drop all terminal rows and layout metadata for an evicted or inactive transcript.
+ * @param transcript - Transcript whose previously returned layout is no longer used.
+ */
+export function releaseHistoryLayout(transcript) {
+    indexes.get(transcript)?.dispose();
+    indexes.delete(transcript);
+}
+/** Lay out an indexed conversation without concatenating its historical rows on every stream frame.
+ * @param transcript - Selected session's semantic content and unfinished assistant output.
+ * @param width - Available terminal columns.
+ * @param reasoning - Global committed/completed reasoning fold mode.
+ * @param overrides - Sequences whose fold mode differs from the global mode; replace the set on changes.
+ * @param liveReasoning - Fold mode for completed blocks in the unfinished assistant attempt.
+ * @returns Row count, sequence offsets, and a viewport reader; `lines` materializes all rows for exports only.
  */
-export function jumpTarget(value) {
-    if (value === 'first' || value === 'last')
-        return value;
-    if (/^\d+$/.test(value) && Number.isSafeInteger(Number(value)))
-        return Number(value);
-    throw new Error('Use /jump <record sequence|first|last>; /history lists record sequences');
+export function historyLayout(transcript, width, reasoning = 'row', overrides = noOverrides, liveReasoning = reasoning) {
+    let index = indexes.get(transcript);
+    if (!index || index.width !== width || index.reasoning !== reasoning || index.overrides !== overrides) {
+        index = new LayoutIndex(width, reasoning, overrides);
+        indexes.set(transcript, index);
+    }
+    index.update(transcript.messagesForWidth(width));
+    const live = transcript.liveParts(width);
+    const streamed = live.length ? [
+        ...(transcript.liveToolOnly || index.assistantSeen ? [] : [{ text: '✦ Assistant · streaming', kind: 'assistant', bold: true }]),
+        ...partRows(live, width, liveReasoning),
+    ] : [];
+    const committed = index;
+    const length = committed.length + streamed.length;
+    const viewport = (start, end) => {
+        start = Math.max(0, start);
+        end = Math.min(length, end);
+        if (end <= start)
+            return [];
+        return [...committed.viewport(start, end), ...streamed.slice(Math.max(0, start - committed.length), Math.max(0, end - committed.length))];
+    };
+    return { messages: index.messages, offsets: index.offsets, first: transcript.beforeSeq, length, liveOffset: committed.length, viewport,
+        get cachedRowCount() { return committed.cachedRowCount; },
+        get lines() { return viewport(0, length).map(row => row.text); } };
 }

package/dist/input-history.d.ts

@@ -0,0 +1,19 @@
+/** Bounded, process-local recall history; never stores transcripts or writes prompt text to disk. */
+export declare class InputHistory {
+    private entries;
+    private bytes;
+    private position;
+    private draft;
+    /** Remember submitted input, coalescing consecutive duplicates and enforcing both budgets.
+     * @param value - Submitted command or prompt, excluding interaction answers.
+     */
+    record(value: string): void;
+    /** Leave recall navigation when the composer is edited or otherwise replaced. */
+    reset(): void;
+    /** Recall older/newer input, restoring the original unsent draft at the end.
+     * @param direction - Negative for older input, positive for newer input.
+     * @param current - Current composer content before beginning recall.
+     * @returns Recalled input, or the original draft when returning to the newest position.
+     */
+    move(direction: -1 | 1, current: string): string;
+}

package/dist/input-history.js

@@ -0,0 +1,43 @@
+/** Bounded, process-local recall history; never stores transcripts or writes prompt text to disk. */
+export class InputHistory {
+    entries = [];
+    bytes = 0;
+    position;
+    draft = '';
+    /** Remember submitted input, coalescing consecutive duplicates and enforcing both budgets.
+     * @param value - Submitted command or prompt, excluding interaction answers.
+     */
+    record(value) {
+        this.reset();
+        if (!value || this.entries.at(-1) === value || value.length * 2 > 256 * 1024)
+            return;
+        this.entries.push(value);
+        this.bytes += value.length * 2;
+        while (this.entries.length > 200 || this.bytes > 256 * 1024)
+            this.bytes -= this.entries.shift().length * 2;
+    }
+    /** Leave recall navigation when the composer is edited or otherwise replaced. */
+    reset() { this.position = undefined; this.draft = ''; }
+    /** Recall older/newer input, restoring the original unsent draft at the end.
+     * @param direction - Negative for older input, positive for newer input.
+     * @param current - Current composer content before beginning recall.
+     * @returns Recalled input, or the original draft when returning to the newest position.
+     */
+    move(direction, current) {
+        if (!this.entries.length)
+            return current;
+        if (this.position === undefined) {
+            if (direction > 0)
+                return current;
+            this.position = this.entries.length;
+            this.draft = current;
+        }
+        this.position = Math.max(0, Math.min(this.entries.length, this.position + direction));
+        if (this.position === this.entries.length) {
+            const draft = this.draft;
+            this.reset();
+            return draft;
+        }
+        return this.entries[this.position];
+    }
+}

package/dist/input.d.ts

@@ -13,11 +13,13 @@ export interface EditState {
  */
 export declare function editInput(state: EditState, input: string, key: Partial<Key>): EditState;
 /** Controlled composer with local cursor and kill buffer; Enter submission belongs to the caller. */
-export declare function TextInput({ value, onChange, onCursorChange, onSubmit, focus, placeholder }: {
+export declare function TextInput({ value, onChange, onCursorChange, onSubmit, focus, placeholder, reservedKeys }: {
     value: string;
     onChange(value: string): void;
     onCursorChange(cursor: number): void;
     onSubmit(): void;
     focus: boolean;
     placeholder: string;
+    /** Keys owned by the surrounding picker while the composer is empty. */
+    reservedKeys?: readonly string[];
 }): import("react").JSX.Element;

package/dist/input.js

@@ -60,7 +60,7 @@ export function editInput(state, input, key) {
     return { ...state, text: text.slice(0, cursor) + inserted + text.slice(cursor), cursor: cursor + inserted.length };
 }
 /** Controlled composer with local cursor and kill buffer; Enter submission belongs to the caller. */
-export function TextInput({ value, onChange, onCursorChange, onSubmit, focus, placeholder }) {
+export function TextInput({ value, onChange, onCursorChange, onSubmit, focus, placeholder, reservedKeys }) {
     const { internal_eventEmitter } = useStdin();
     const rawKey = useRef('');
     useEffect(() => {
@@ -77,6 +77,8 @@ export function TextInput({ value, onChange, onCursorChange, onSubmit, focus, pl
     useInput((input, key) => {
         if (key.eventType === 'release' || isMouseReport(rawKey.current))
             return;
+        if (!current.current.text && !key.ctrl && !key.meta && reservedKeys?.includes(input))
+            return;
         if (key.return) {
             onSubmit();
             return;

package/dist/memory.d.ts

@@ -0,0 +1,13 @@
+/** Soft budgets for reloadable semantic history, excluding active output and protected reading. */
+export interface HistoryLimits {
+    maxRecords: number;
+    maxBytes: number;
+}
+/** Default balance: keep recent history in memory, reload older records through the host. */
+export declare const DEFAULT_HISTORY_LIMITS: HistoryLimits;
+/** Parse optional CLI limits before opening a connection or writing application state.
+ * @param records - Maximum retained semantic records, as a positive integer.
+ * @param megabytes - Estimated semantic payload budget in MiB, as a positive integer.
+ * @returns Validated history budgets, using defaults for omitted options.
+ */
+export declare function historyLimits(records?: string, megabytes?: string): HistoryLimits;

package/dist/memory.js

@@ -0,0 +1,22 @@
+/** Default balance: keep recent history in memory, reload older records through the host. */
+export const DEFAULT_HISTORY_LIMITS = { maxRecords: 2000, maxBytes: 16 * 1024 * 1024 };
+/** Parse optional CLI limits before opening a connection or writing application state.
+ * @param records - Maximum retained semantic records, as a positive integer.
+ * @param megabytes - Estimated semantic payload budget in MiB, as a positive integer.
+ * @returns Validated history budgets, using defaults for omitted options.
+ */
+export function historyLimits(records, megabytes) {
+    const positive = (value, fallback, name) => {
+        if (value === undefined)
+            return fallback;
+        const parsed = Number(value);
+        if (!/^\d+$/.test(value) || !Number.isSafeInteger(parsed) || parsed < 1)
+            throw new Error(`${name} must be a positive integer`);
+        return parsed;
+    };
+    const maxRecords = positive(records, DEFAULT_HISTORY_LIMITS.maxRecords, '--history-records');
+    const maxBytes = positive(megabytes, DEFAULT_HISTORY_LIMITS.maxBytes / 1048576, '--history-mb') * 1048576;
+    if (!Number.isSafeInteger(maxBytes))
+        throw new Error('--history-mb is too large');
+    return { maxRecords, maxBytes };
+}

package/dist/mouse.d.ts

@@ -10,5 +10,7 @@ export declare function isMouseReport(raw: string): boolean;
 export declare function wheelDirection(raw: string): number;
 /** Enable cell-based mouse reports for this mount and restore normal terminal behavior on exit.
  * @param scroll - Current transcript scrolling callback.
+ * @param enabled - False restores native terminal selection while display updates are paused.
+ * @param select - Left press callback that can freeze the display and release mouse capture.
  */
-export declare function useMouseWheel(scroll: (direction: number) => void): void;
+export declare function useMouseWheel(scroll: (direction: number) => void, enabled?: boolean, select?: () => void): void;

package/dist/mouse.js

@@ -20,15 +20,26 @@ export function wheelDirection(raw) {
 }
 /** Enable cell-based mouse reports for this mount and restore normal terminal behavior on exit.
  * @param scroll - Current transcript scrolling callback.
+ * @param enabled - False restores native terminal selection while display updates are paused.
+ * @param select - Left press callback that can freeze the display and release mouse capture.
  */
-export function useMouseWheel(scroll) {
+export function useMouseWheel(scroll, enabled = true, select) {
     const { internal_eventEmitter } = useStdin();
     const { stdout } = useStdout();
     const callback = useRef(scroll);
     callback.current = scroll;
+    const selection = useRef(select);
+    selection.current = select;
     useEffect(() => {
-        const onInput = (raw) => { const direction = wheelDirection(raw); if (direction)
-            callback.current(direction); };
+        if (!enabled)
+            return;
+        const onInput = (raw) => {
+            const direction = wheelDirection(raw);
+            if (direction)
+                callback.current(direction);
+            else if (/^\x1b\[<0;\d+;\d+M$/.test(raw))
+                selection.current?.();
+        };
         internal_eventEmitter.on('input', onInput);
         if (stdout.isTTY)
             stdout.write('\x1b[?1006h\x1b[?1000h');
@@ -37,5 +48,5 @@ export function useMouseWheel(scroll) {
             if (stdout.isTTY)
                 stdout.write('\x1b[?1000l\x1b[?1006l');
         };
-    }, [internal_eventEmitter, stdout]);
+    }, [internal_eventEmitter, stdout, enabled]);
 }

package/dist/navigation.d.ts

@@ -1,6 +1,6 @@
 /** Shared display names and unambiguous slash-command target resolution. */
 import { type ObjectValue } from './wire.ts';
-/** Parse the short navigation commands and their equivalent long aliases. */
+/** Parse workspace and resume navigation, including their long aliases. */
 export declare function navigationCommand(value: string): {
     kind: 'workspace' | 'session';
     query?: string;

package/dist/navigation.js

@@ -1,8 +1,8 @@
 /** Shared display names and unambiguous slash-command target resolution. */
 import { safeText, string } from "./wire.js";
-/** Parse the short navigation commands and their equivalent long aliases. */
+/** Parse workspace and resume navigation, including their long aliases. */
 export function navigationCommand(value) {
-    const match = /^\/(ws|workspace|workspaces|s|session|sessions)(?:\s+(.+))?$/.exec(value);
+    const match = /^\/(ws|workspace|workspaces|resume|session|sessions)(?:\s+(.+))?$/.exec(value);
     if (!match)
         return undefined;
     return { kind: match[1] === 'ws' || match[1].startsWith('workspace') ? 'workspace' : 'session', query: match[2] };

package/dist/status.d.ts

@@ -13,7 +13,7 @@ export declare function elapsedTime(milliseconds: number): string;
  */
 export declare function metricLines(values: ObjectValue, defaultModel: ObjectValue | undefined, running: boolean): string[];
 /** 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.
  */
@@ -22,5 +22,7 @@ export declare function compactStatus(fields: string[], width: number): string;
 export declare const StatusBar: import("react").NamedExoticComponent<{
     controller: Controller;
     expanded?: boolean;
+    width?: number;
     revision?: number;
+    paused?: boolean;
 }>;